skybridge 0.0.0-dev.e3e0986 → 0.0.0-dev.e41a369

package/README.md

@@ -1,320 +1,123 @@
 <div align="center">
 
-# Skybridge
-
-**Skybridge is the TypeScript framework for building ChatGPT apps**
-
-[![By Alpic](https://img.shields.io/badge/Made%20by%20Alpic-f6ffed?logo=alpic)](https://alpic.ai)
+<img alt="Skybridge" src="docs/static/img/logo.png" width="220">
 
-![NPM Downloads](https://img.shields.io/npm/dm/skybridge?color=e90060)
-![NPM Version](https://img.shields.io/npm/v/skybridge?color=e90060)
-![GitHub License](https://img.shields.io/github/license/alpic-ai/skybridge?color=e90060)
+# Skybridge
 
-</div>
+**Build ChatGPT Apps. The Modern TypeScript Way.**
 
-Skybridge comes with 2 packages:
+The fullstack TypeScript framework for ChatGPT Apps.<br />
+**Type-safe. React-powered. Zero config.**
 
-- `skybridge/server`: A drop-in replacement of the `@modelcontextprotocol/sdk` official `McpServer` class with extra features for widget development.
-- `skybridge/web`: A react library with hooks and components to build widgets on the underlying _OpenAI iFrame skybridge_ runtime.
+<br />
 
-## Quick start
+[![NPM Version](https://img.shields.io/npm/v/skybridge?color=e90060&style=for-the-badge)](https://www.npmjs.com/package/skybridge)
+[![NPM Downloads](https://img.shields.io/npm/dm/skybridge?color=e90060&style=for-the-badge)](https://www.npmjs.com/package/skybridge)
+[![GitHub License](https://img.shields.io/github/license/alpic-ai/skybridge?color=e90060&style=for-the-badge)](https://github.com/alpic-ai/skybridge/blob/main/LICENSE)
 
-To get started in less than a minute, you can [create a new repository](https://github.com/new?template_name=apps-sdk-template&template_owner=alpic-ai) using our [ChatGPT SDK template](https://github.com/alpic-ai/apps-sdk-template). This template includes a basic setup for both the server and the widgets.
+<br />
 
-## Installation
+[Documentation](https://skybridge.tech) · [Quick Start](https://github.com/new?template_name=apps-sdk-template&template_owner=alpic-ai) · [Examples](https://github.com/alpic-ai/apps-sdk-template)
 
-```bash
-pnpm add skybridge
-```
+</div>
 
-## Concepts
+<br />
 
-### Widgets
+## ✨ Why Skybridge?
 
-> A widget is a UI component that turns structured tool results into a human-friendly UI. Those are built using React components. They are rendered inside an iframe inline with the conversation on ChatGPT.
+ChatGPT Apps let you embed **rich, interactive UIs** directly in conversations. But the raw SDK is low-level—no hooks, no type safety, no dev tools, and no HMR.
 
-Each widget in your app must have a unique name. The name is used to bridge the tool invocation result with the widget React component.
+**Skybridge fixes that.**
 
-For example, in order to register a new widget named `pokemon` on your ChatGPT app. You should have the following file structure and file contents:
+| | |
+|:--|:--|
+| 👨‍💻 **Full Dev Environment** — HMR, debug traces, and local emulator. No more refresh loops. | ✅ **End-to-End Type Safety** — tRPC-style inference from server to widget. Autocomplete everywhere. |
+| 🔄 **Widget-to-Model Sync** — Keep the model aware of UI state with `data-llm`. Dual surfaces, one source of truth. | ⚒️ **React Query-style Hooks** — `isPending`, `isError`, callbacks. State management you already know. |
 
-_Project structure_
+<br />
 
-```
-server/
-└── src/
-    └── index.ts // Register the widget with McpServer.widget()
-web/
-└── src/
-    └── widgets/
-        └── pokemon.tsx // Use the same widget name as the file name
-```
+## 🚀 Get Started
 
-_server/src/index.ts_
+**Create a new ChatGPT app:**
 
-```ts
-import { McpServer } from "skybridge/server";
-
-const server = new McpServer();
-
-server.widget(
-  "pokemon"
-  // Remaining arguments...
-);
+```bash
+gh repo create my-app --template alpic-ai/apps-sdk-template --clone
+cd my-app && pnpm install
 ```
 
-_web/src/widgets/pokemon.tsx_
+**Or add to an existing project:**
 
-```ts
-import { mountWidget } from "skybridge/web";
-
-const Pokemon: React.FunctionComponent = () => {
-  // Your React component code goes here...
-};
-
-mountWidget(<Pokemon />);
+```bash
+npm i skybridge
+yarn add skybridge
+pnpm add skybridge
+bun add skybridge
+deno add skybridge
 ```
 
-## Packages
-
-### skybridge/server
-
-The `skybridge/server` package is a drop-in replacement of the `@modelcontextprotocol/sdk` official `McpServer` class with extra features for widget development. If you're already using the `@modelcontextprotocol/sdk`, you can simply replace your `McpServer` import with `skybridge/server` and you're good to go.
-
-### skybridge/web
-
-The `skybridge/web` package is a react library with hooks and components to build widgets on the underlying _OpenAI iFrame skybridge_ runtime.
-
-**Vite plugin**
+<div align="center">
 
-The `skybridge/web` package comes with a Vite plugin that allows you to build your widgets as regular Vite apps.
+**👉 [Read the Docs](https://skybridge.tech) 👈**
 
-```ts
-import { defineConfig } from "vite";
-import { skybridge } from "skybridge/web";
+</div>
 
-export default defineConfig({
-  plugins: [skybridge()],
-});
-```
+<br />
 
-**Typed Hooks**
+## 📦 The Stack
 
-Skybridge provides fully typed hooks that give you autocomplete for tool names and type inference for inputs/outputs - similar to tRPC. This is opt-in and requires exporting your server type.
+- **`skybridge/server`** — Drop-in MCP SDK replacement with widget registration and type inference.
+- **`skybridge/web`** — React hooks and components for ChatGPT's runtime.
 
-_Server setup (server/src/index.ts)_
+### Server
 
 ```ts
 import { McpServer } from "skybridge/server";
-import { z } from "zod";
-
-const server = new McpServer({ name: "my-app", version: "1.0" }, {})
-  .widget("search-voyage", {}, {
-    description: "Search for trips",
-    inputSchema: {
-      destination: z.string(),
-      departureDate: z.string().optional(),
-    },
-    outputSchema: {
-      results: z.array(z.object({ id: z.string(), name: z.string() })),
-    },
-  }, async ({ destination }) => {
-    // Your tool logic here...
-    return { content: [{ type: "text", text: `Found trips to ${destination}` }] };
-  })
-  .widget("get-details", {}, {
-    inputSchema: { tripId: z.string() },
-  }, async ({ tripId }) => {
-    return { content: [{ type: "text", text: `Details for ${tripId}` }] };
-  });
-
-// Export the server type for the client
-export type AppType = typeof server;
-```
 
-_One-time setup (web/src/skybridge.ts)_
-
-Create typed hooks once and export them for use across your app:
-
-```ts
-import type { AppType } from "../server"; // type-only import
-import { createTypedHooks } from "skybridge/web";
-
-export const { useCallTool, useToolInfo } = createTypedHooks<AppType>();
+server.registerWidget("flights", {}, {
+  inputSchema: { destination: z.string() },
+}, async ({ destination }) => {
+  const flights = await searchFlights(destination);
+  return { structuredContent: { flights } };
+});
 ```
 
-_Usage in widgets (web/src/widgets/search.tsx)_
+### Widget
 
 ```tsx
-import { useCallTool, useToolInfo } from "../skybridge"; // import typed hooks
-
-export function SearchWidget() {
-  const { callTool, data, isPending } = useCallTool("search-voyage");
-  //                                                 ^ autocomplete for tool names
-  const toolInfo = useToolInfo<"search-voyage">();
-  //                              ^ autocomplete for widget names
-
-  const handleSearch = () => {
-    callTool({ destination: "Spain" });
-    //         ^ autocomplete for input fields
-  };
-
-  return (
-    <div>
-      <button onClick={handleSearch} disabled={isPending}>
-        Search
-      </button>
-      {toolInfo.isSuccess && (
-        <div>Found {toolInfo.output.totalCount} results</div>
-        //                      ^ typed output
-      )}
-    </div>
-  );
-}
-```
-
-**Hooks**
-
-The `skybridge/web` package comes with a set of hooks to help you build your widgets :
-
-- `useOpenAiGlobal`: A generic hook to get any global data from the OpenAI iFrame skybridge runtime (in `window.openai`).
-- `useToolOutput`: A hook to get the initial tool `structuredContent` returned when rendering the widget for the first time. The data inside this hook is not updated when the tool is called again.
-- `useToolResponseMetadata`: A hook to get the initial tool `meta` returned when rendering the widget for the first time. The data inside this hook is not updated when the tool is called again.
-- `useToolInfo`: A hook to get the tool input, output, and response metadata with type inference. Provides a discriminated union based on status (pending/success).
-- `useCallTool`: A @tanstack/react-query inspired hook to send make additional tool calls inside a widget.
-- `createTypedHooks`: A factory that creates typed versions of `useCallTool` and `useToolInfo` with full type inference from your server type.
-
-_useOpenAiGlobal_
-
-```ts
-import { useOpenAiGlobal } from "skybridge/web";
-
-const theme = useOpenAiGlobal("theme");
-```
-
-_useToolOutput_
-
-```ts
-import { useToolOutput } from "skybridge/web";
-
-const toolOutput = useToolOutput();
-```
-
-_useToolResponseMetadata_
-
-```ts
-import { useToolResponseMetadata } from "skybridge/web";
-
-const toolResponseMetadata = useToolResponseMetadata();
-```
-
-_useToolInfo_
-
-```ts
 import { useToolInfo } from "skybridge/web";
 
-const toolInfo = useToolInfo<{
-  input: { query: string };
-  output: { results: string[] };
-  responseMetadata: { id: number };
-}>();
+function FlightsWidget() {
+  const { output } = useToolInfo();
 
-// toolInfo.input is typed based on the input type
-// toolInfo.output is typed based on the output type (undefined when pending)
-// toolInfo.status narrows correctly: "pending" | "success"
-
-if (toolInfo.isPending) {
-  // toolInfo.output is undefined here
-  console.log(toolInfo.input.query);
-}
-
-if (toolInfo.isSuccess) {
-  // toolInfo.output is typed here
-  console.log(toolInfo.output.results);
+  return output.structuredContent.flights.map(f =>
+    <FlightCard key={f.id} flight={f} />
+  );
 }
 ```
 
-_useToolInfo_ with typed hooks (recommended)
-
-```tsx
-import { useToolInfo } from "../skybridge"; // import typed hooks
-
-export function SearchWidget() {
-  const toolInfo = useToolInfo<"search-voyage">();
-  //                              ^ autocomplete for widget names
-  // toolInfo.input is typed as { destination: string; departureDate?: string; ... }
-  // toolInfo.output is typed as { results: Array<...>; totalCount: number; } | undefined
+<br />
 
-  if (toolInfo.isSuccess) {
-    return <div>Found {toolInfo.output.totalCount} results</div>;
-  }
+## 🎯 Features at a Glance
 
-  return <div>Searching for {toolInfo.input.destination}...</div>;
-}
-```
-
-_useCallTool_ in synchronous mode
-
-```ts
-import { useCallTool } from "skybridge/web";
-
-export const TestTool: React.FunctionComponent = () => {
-  const { callTool, isPending } = useCallTool("myToolName");
-
-  return (
-    <div>
-      <button
-        disabled={isPending}
-        onClick={() => {
-          callTool({ input: "test input" }, {
-            onSuccess: (data) => {
-              alert("Tool returned: " + data);
-            },
-          });
-      >
-        Call Tool inside a widget
-      </button>
-    </div>
-  );
-};
-```
+- **Live Reload** — Vite HMR. See changes instantly without reinstalling.
+- **Typed Hooks** — Full autocomplete for tools, inputs, outputs.
+- **Widget → Tool Calls** — Trigger server actions from UI.
+- **Dual Surface Sync** — Keep model aware of what users see with `data-llm`.
+- **React Query-style API** — `isPending`, `isError`, callbacks.
+- **MCP Compatible** — Extends the official SDK. Works with any MCP client.
 
-_useCallTool_ in asynchronous mode
+<br />
 
-```ts
-import { useCallTool } from "skybridge/web";
-
-export const TestTool: React.FunctionComponent = () => {
-  const { callToolAsync, isPending } = useCallTool("myToolName");
-
-  return (
-    <div>
-      <button
-        disabled={isPending}
-        onClick={async () => {
-          const data = await callToolAsync({ input: "test input" });
-          alert("Tool returned: " + data);
-        }}
-      >
-        Call Tool inside a widget
-      </button>
-    </div>
-  );
-};
-```
+<div align="center">
 
-## Migrate your existing MCP server to a ChatGPT app
+[![GitHub Discussions](https://img.shields.io/badge/Discussions-Ask%20Questions-blue?style=flat-square&logo=github)](https://github.com/alpic-ai/skybridge/discussions)
+[![GitHub Issues](https://img.shields.io/badge/Issues-Report%20Bugs-red?style=flat-square&logo=github)](https://github.com/alpic-ai/skybridge/issues)
+[![Discord](https://img.shields.io/badge/Discord-Chat-5865F2?style=flat-square&logo=discord&logoColor=white)](https://discord.com/invite/gNAazGueab)
 
-If you're already using the `@modelcontextprotocol/sdk` to build a MCP server, you can migrate to a ChatGPT app by following these steps:
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions
 
-1. Replace your `McpServer` import from `@modelcontextprotocol/sdk` with the same import from `skybridge/server`
-2. Create a new vite project in a folder named `web` and install the `skybridge` package
-3. Replace the `vite.config.ts` file with the following:
+<br />
 
-```ts
-import { defineConfig } from "vite";
-import { skybridge } from "skybridge/web";
+**[MIT License](LICENSE)** · Made with ❤️ by **[Alpic](https://alpic.ai)**
 
-export default defineConfig({
-  plugins: [skybridge()],
-});
-```
+</div>

package/dist/src/server/emulatorStaticServer.d.ts

@@ -0,0 +1,15 @@
+import { type RequestHandler } from "express";
+/**
+ * Serve the built emulator React app
+ * This router serves static files from the emulator's dist directory.
+ * It should be installed at the application root, like so:
+ *
+ *  const app = express();
+ *
+ * if (env.NODE_ENV !== "production") {
+ *   app.use(await emulatorStaticServer(server));
+ *   app.use(await widgetsDevServer());
+ *                     ^^^^^^^^ Make sure to install the emulatorStaticServer before the widgetsDevServer
+ * }
+ */
+export declare const emulatorStaticServer: () => Promise<RequestHandler>;

package/dist/src/server/emulatorStaticServer.js

@@ -0,0 +1,38 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import cors from "cors";
+import express, {} from "express";
+/**
+ * Serve the built emulator React app
+ * This router serves static files from the emulator's dist directory.
+ * It should be installed at the application root, like so:
+ *
+ *  const app = express();
+ *
+ * if (env.NODE_ENV !== "production") {
+ *   app.use(await emulatorStaticServer(server));
+ *   app.use(await widgetsDevServer());
+ *                     ^^^^^^^^ Make sure to install the emulatorStaticServer before the widgetsDevServer
+ * }
+ */
+export const emulatorStaticServer = async () => {
+    const router = express.Router();
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const emulatorPath = path.join(currentDir, "..", "emulator");
+    router.use(cors());
+    router.use(express.static(emulatorPath));
+    router.get("/", (_req, res, next) => {
+        const indexHtmlPath = path.join(emulatorPath, "index.html");
+        try {
+            const indexHtml = readFileSync(indexHtmlPath, "utf-8");
+            res.setHeader("Content-Type", "text/html");
+            res.send(indexHtml);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    return router;
+};
+//# sourceMappingURL=emulatorStaticServer.js.map

package/dist/src/server/emulatorStaticServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emulatorStaticServer.js","sourceRoot":"","sources":["../../../src/server/emulatorStaticServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,OAAO,EAAE,EAAuB,MAAM,SAAS,CAAC;AAEvD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,KAAK,IAA6B,EAAE;IACtE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAChC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAChE,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;IAE7D,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;IAEnB,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;IAEzC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;QAClC,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QAC5D,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,YAAY,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;YACvD,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;YAC3C,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACtB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CAAC,CAAC;QACd,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

package/dist/src/server/index.d.ts

@@ -1,4 +1,5 @@
+export { emulatorStaticServer } from "./emulatorStaticServer.js";
+export type { AnyToolRegistry, InferTools, ToolInput, ToolNames, ToolOutput, ToolResponseMetadata, } from "./inferUtilityTypes.js";
+export type { McpServerTypes, ToolDef } from "./server.js";
 export { McpServer } from "./server.js";
 export { widgetsDevServer } from "./widgetsDevServer.js";
-export type { WidgetDef } from "./server.js";
-export type { InferWidgets, AnyWidgetRegistry, WidgetNames, WidgetInput, WidgetOutput, } from "./inferUtilityTypes.js";

package/dist/src/server/index.js

@@ -1,3 +1,4 @@
+export { emulatorStaticServer } from "./emulatorStaticServer.js";
 export { McpServer } from "./server.js";
 export { widgetsDevServer } from "./widgetsDevServer.js";
 //# sourceMappingURL=index.js.map

package/dist/src/server/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAUjE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/src/server/inferUtilityTypes.d.ts

@@ -1,33 +1,64 @@
-import type { McpServer, WidgetDef } from "./server.js";
-/** Any widget registry shape */
-export type AnyWidgetRegistry = Record<string, WidgetDef>;
+import type { McpServerTypes, ToolDef } from "./server.js";
 /**
- * Extract the widget registry type from an McpServer instance.
+ * Any tool registry shape (includes both widgets and regular tools).
+ * Used as a constraint for type parameters that accept tool registries.
+ */
+export type AnyToolRegistry = Record<string, ToolDef>;
+/**
+ * Extract the tool registry type from an McpServer instance.
+ * This includes both widgets (registered via widget()) and regular tools (registered via registerTool()).
+ *
+ * Uses the `$types` property pattern for cross-package type inference.
+ * This works across package boundaries because TypeScript uses structural typing
+ * on the shape of `$types`, rather than nominal typing on the McpServer class itself.
+ *
+ * @example
+ * ```ts
+ * type MyTools = InferTools<MyServer>;
+ * // { "search": ToolDef<...>, "calculate": ToolDef<...> }
+ * ```
+ */
+export type InferTools<ServerType> = ServerType extends {
+    $types: McpServerTypes<infer W>;
+} ? W : never;
+type ExtractTool<ServerType, K extends ToolNames<ServerType>> = InferTools<ServerType>[K];
+/**
+ * Get a union of all tool names from an McpServer instance.
+ * This includes both widgets and regular tools.
+ *
+ * @example
+ * ```ts
+ * type Names = ToolNames<MyServer>;
+ * // "search" | "calculate" | "details"
+ * ```
+ */
+export type ToolNames<ServerType> = keyof InferTools<ServerType> & string;
+/**
+ * Get the input type for a specific tool (widget or regular tool).
  *
  * @example
  * ```ts
- * type MyWidgets = InferWidgets<MyServer>;
- * // { "search": WidgetDef<...>, "details": WidgetDef<...> }
+ * type SearchInput = ToolInput<MyServer, "search">;
  * ```
  */
-export type InferWidgets<T> = T extends McpServer<infer W extends AnyWidgetRegistry> ? W : T extends McpServer<any> ? never : "Error: T must be an McpServer instance";
-/** Get a union of all widget names from an McpServer instance */
-export type WidgetNames<T> = keyof InferWidgets<T> & string;
+export type ToolInput<ServerType, ToolName extends ToolNames<ServerType>> = ExtractTool<ServerType, ToolName>["input"];
 /**
- * Get the input type for a specific widget.
+ * Get the output type for a specific tool (widget or regular tool).
  *
  * @example
  * ```ts
- * type SearchInput = WidgetInput<MyServer, "search">;
+ * type SearchOutput = ToolOutput<MyServer, "search">;
  * ```
  */
-export type WidgetInput<T, K extends WidgetNames<T>> = InferWidgets<T> extends Record<string, WidgetDef> ? K extends keyof InferWidgets<T> ? InferWidgets<T>[K]["input"] : never : never;
+export type ToolOutput<ServerType, ToolName extends ToolNames<ServerType>> = ExtractTool<ServerType, ToolName>["output"];
 /**
- * Get the output type for a specific widget.
+ * Get the responseMetadata type for a specific tool (widget or regular tool).
+ * This is inferred from the `_meta` property of the tool callback's return value.
  *
  * @example
  * ```ts
- * type SearchOutput = WidgetOutput<MyServer, "search">;
+ * type SearchMeta = ToolResponseMetadata<MyServer, "search">;
  * ```
  */
-export type WidgetOutput<T, K extends WidgetNames<T>> = InferWidgets<T> extends Record<string, WidgetDef> ? K extends keyof InferWidgets<T> ? InferWidgets<T>[K]["output"] : never : never;
+export type ToolResponseMetadata<ServerType, ToolName extends ToolNames<ServerType>> = ExtractTool<ServerType, ToolName>["responseMetadata"];
+export {};

package/dist/src/server/server.d.ts

@@ -1,19 +1,62 @@
-import { McpServer as McpServerBase, type ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { Resource } from "@modelcontextprotocol/sdk/types.js";
-import type { ZodRawShape, ZodObject, infer as Infer } from "zod";
-export type WidgetDef<TInput = unknown, TOutput = unknown> = {
+import { McpServer as McpServerBase, type RegisteredTool } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { AnySchema, SchemaOutput, ZodRawShapeCompat } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { CallToolResult, Resource, ServerNotification, ServerRequest, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+export type ToolDef<TInput = unknown, TOutput = unknown, TResponseMetadata = unknown> = {
     input: TInput;
     output: TOutput;
+    responseMetadata: TResponseMetadata;
 };
 type McpServerOriginalResourceConfig = Omit<Resource, "uri" | "name" | "mimeType">;
-type McpServerOriginalToolConfig = Omit<Parameters<McpServerBase["registerTool"]>[1], "inputSchema" | "outputSchema">;
-export declare class McpServer<TWidgets extends Record<string, WidgetDef> = {}> extends McpServerBase {
-    widget<TName extends string, TInput extends ZodRawShape, TOutput extends ZodRawShape = {}>(name: TName, resourceConfig: McpServerOriginalResourceConfig, toolConfig: McpServerOriginalToolConfig & {
+type McpServerOriginalToolConfig = Omit<Parameters<typeof McpServerBase.prototype.registerTool<ZodRawShapeCompat, ZodRawShapeCompat>>[1], "inputSchema" | "outputSchema">;
+type ExtractStructuredContent<T> = T extends {
+    structuredContent: infer SC;
+} ? SC : never;
+type ExtractMeta<T> = Extract<T, {
+    _meta: unknown;
+}> extends {
+    _meta: infer M;
+} ? M : unknown;
+/**
+ * Type-level marker interface for cross-package type inference.
+ * This enables TypeScript to infer tool types across package boundaries
+ * using structural typing on the $types property, rather than relying on
+ * class generic inference which fails when McpServer comes from different
+ * package installations.
+ *
+ * Inspired by tRPC's _def pattern and Hono's type markers.
+ */
+export interface McpServerTypes<TTools extends Record<string, ToolDef> = {}> {
+    readonly tools: TTools;
+}
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+type ShapeOutput<Shape extends ZodRawShapeCompat> = Simplify<{
+    [K in keyof Shape as undefined extends SchemaOutput<Shape[K]> ? never : K]: SchemaOutput<Shape[K]>;
+} & {
+    [K in keyof Shape as undefined extends SchemaOutput<Shape[K]> ? K : never]?: SchemaOutput<Shape[K]>;
+}>;
+type AddTool<TTools, TName extends string, TInput extends ZodRawShapeCompat, TOutput, TResponseMetadata = unknown> = McpServer<TTools & {
+    [K in TName]: ToolDef<ShapeOutput<TInput>, TOutput, TResponseMetadata>;
+}>;
+type ToolConfig<TInput extends ZodRawShapeCompat | AnySchema> = {
+    title?: string;
+    description?: string;
+    inputSchema?: TInput;
+    outputSchema?: ZodRawShapeCompat | AnySchema;
+    annotations?: ToolAnnotations;
+    _meta?: Record<string, unknown>;
+};
+type ToolHandler<TInput extends ZodRawShapeCompat, TReturn extends CallToolResult = CallToolResult> = (args: ShapeOutput<TInput>, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => TReturn | Promise<TReturn>;
+export declare class McpServer<TTools extends Record<string, ToolDef> = {}> extends McpServerBase {
+    readonly $types: McpServerTypes<TTools>;
+    registerWidget<TName extends string, TInput extends ZodRawShapeCompat, TReturn extends CallToolResult>(name: TName, resourceConfig: McpServerOriginalResourceConfig, toolConfig: McpServerOriginalToolConfig & {
         inputSchema?: TInput;
-        outputSchema?: TOutput;
-    }, toolCallback: ToolCallback<TInput>): McpServer<TWidgets & {
-        [K in TName]: WidgetDef<Infer<ZodObject<TInput>>, Infer<ZodObject<TOutput>>>;
-    }>;
+        outputSchema?: ZodRawShapeCompat | AnySchema;
+    }, toolCallback: ToolHandler<TInput, TReturn>): AddTool<TTools, TName, TInput, ExtractStructuredContent<TReturn>, ExtractMeta<TReturn>>;
+    registerTool<TName extends string, InputArgs extends ZodRawShapeCompat, TReturn extends CallToolResult>(name: TName, config: ToolConfig<InputArgs>, cb: ToolHandler<InputArgs, TReturn>): AddTool<TTools, TName, InputArgs, ExtractStructuredContent<TReturn>, ExtractMeta<TReturn>>;
+    registerTool<InputArgs extends ZodRawShapeCompat>(name: string, config: ToolConfig<InputArgs>, cb: ToolHandler<InputArgs>): RegisteredTool;
     private lookupDistFile;
 }
 export {};