@guuey/create-agentic-app 0.1.0

package/dist/templates/claude-agent-sdk/web/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "useDefineForClassFields": true,
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "types": ["vite/client"]
+  },
+  "include": ["src", "vite.config.ts", "sandbox-proxy.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/templates/claude-agent-sdk/web/vite.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { sandboxProxyPlugin } from "./sandbox-proxy";
+
+// Port is passed via the `dev` script's `--port 6890` flag (see package.json)
+// so it stays visible in one place; `scripts/dev.mjs` boots this on the same
+// port. The sandbox proxy plugin serves the MCP-Apps sandbox page on :6891 —
+// a SECOND origin, as the spec's double-iframe architecture requires (see
+// ./sandbox-proxy.ts).
+export default defineConfig({
+  plugins: [react(), sandboxProxyPlugin()],
+});

package/dist/templates/mcp-base/Dockerfile

@@ -0,0 +1,46 @@
+# NAME_PLACEHOLDER-mcp — guuey hosted MCP server image.
+#
+# Self-sufficient multi-stage build: `guuey mcp deploy` packs this directory
+# into a tarball and hands it straight to the builder with no external
+# pre-build step and no build args — this Dockerfile installs its own deps
+# and builds itself. (Different from guuey's own first-party MCP servers,
+# which use a "copy-prebuilt" pattern that expects `dist/` + `node_modules/`
+# to already exist before `docker build` runs — that pattern does not apply
+# to a standalone project like this one.)
+#
+# Build + run locally:
+#
+#   docker build -t NAME_PLACEHOLDER-mcp .
+#   docker run -p 8080:8080 NAME_PLACEHOLDER-mcp
+#   curl http://localhost:8080/health
+#
+# Deploy to guuey:
+#
+#   cd mcps/NAME_PLACEHOLDER && guuey mcp deploy
+
+FROM node:22-slim AS build
+WORKDIR /app
+COPY package.json ./
+RUN npm install
+COPY tsconfig.json ./
+COPY src ./src
+RUN npm run build
+
+FROM node:22-slim
+WORKDIR /app
+ENV NODE_ENV=production
+# guuey's hosted-MCP runtime injects PORT=8080 and probes GET /health at that
+# port — this default matches so `docker run` alone also works.
+ENV PORT=8080
+
+COPY package.json ./
+RUN npm install --omit=dev
+COPY --from=build /app/dist ./dist
+
+USER node
+EXPOSE 8080
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+  CMD node -e "fetch('http://localhost:' + (process.env.PORT || 8080) + '/health').then(r => { if (!r.ok) throw 1 }).catch(() => process.exit(1))"
+
+CMD ["node", "dist/server.js"]

package/dist/templates/mcp-base/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@agentic-app-template/NAME_PLACEHOLDER-mcp",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx src/server.ts",
+    "build": "tsup src/server.ts --format esm -d dist",
+    "start": "node dist/server.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.0"
+  }
+}

package/dist/templates/mcp-base/src/server.ts

@@ -0,0 +1,113 @@
+/**
+ * NAME_PLACEHOLDER-mcp — the copy-me starter MCP server for
+ * @agentic-app-template.
+ *
+ * A minimal, stateless Streamable HTTP MCP server with a single example
+ * tool (`echo`). Replace the example tool with your own real tools;
+ * everything else (transport wiring, `/health` + `PORT` contract) stays the
+ * same.
+ *
+ * Transport pattern mirrors guuey's canonical hosted-MCP scaffold
+ * (`mcp-servers/_template` in the guuey monorepo): a fresh `McpServer` +
+ * `StreamableHTTPServerTransport` are created **per request** and torn down
+ * when the response closes. Stateless mode — the guuey proxy (and, locally,
+ * whatever MCP client you point at this server) handles sessions, so this
+ * server never keeps request state around between calls.
+ *
+ * Runtime contract when deployed via `guuey mcp deploy` (see this
+ * directory's Dockerfile): the platform injects `PORT=8080` and probes
+ * `GET /health` for both liveness and readiness. Locally, `pnpm dev` runs
+ * this on `PORT=6782` when scaffolded as a workspace member of a guuey
+ * project (see ../../scripts/dev.mjs there).
+ */
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
+
+const SERVER_NAME = "NAME_PLACEHOLDER-mcp";
+
+/** Wrap a structured result as both `structuredContent` and a text block. */
+function toolResult(data: Record<string, unknown>) {
+  return {
+    structuredContent: data,
+    content: [{ type: "text" as const, text: JSON.stringify(data) }],
+  };
+}
+
+function buildMcpServer(): McpServer {
+  const server = new McpServer({
+    name: SERVER_NAME,
+    version: "0.0.0",
+    description: "Example MCP server — replace the echo tool with your own.",
+  });
+
+  server.registerTool(
+    "echo",
+    {
+      title: "Echo",
+      description: "Echo a message back. Replace this with your own tool.",
+      inputSchema: { message: z.string().min(1).describe("Message to echo back.") },
+      outputSchema: { message: z.string() },
+    },
+    async ({ message }) => toolResult({ message }),
+  );
+
+  return server;
+}
+
+const PORT = Number(process.env.PORT ?? 6782);
+
+const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+  if (req.method === "GET" && req.url === "/health") {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", server: SERVER_NAME, version: "0.0.0" }));
+    return;
+  }
+
+  if (req.url !== "/mcp") {
+    res.writeHead(404, { "content-type": "application/json" }).end(
+      JSON.stringify({ error: "not found" }),
+    );
+    return;
+  }
+
+  // Fresh server + transport per request (stateless mode) — see module doc.
+  const mcp = buildMcpServer();
+  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+
+  res.on("close", () => {
+    transport.close().catch(() => undefined);
+    mcp.close().catch(() => undefined);
+  });
+
+  try {
+    await mcp.connect(transport);
+    await transport.handleRequest(req, res);
+  } catch (err) {
+    console.error("mcp_handle_failed", err);
+    if (!res.headersSent) {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32603, message: "Internal server error" },
+          id: null,
+        }),
+      );
+    }
+  }
+});
+
+httpServer.listen(PORT, () => {
+  console.log(`${SERVER_NAME} listening on :${PORT}`);
+});
+
+function shutdown(signal: string): void {
+  console.log(`${signal} received — shutting down`);
+  httpServer.close(() => process.exit(0));
+  // Force-exit if connections don't drain in time.
+  setTimeout(() => process.exit(1), 10_000).unref();
+}
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));

package/dist/templates/mcp-base/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/templates/openai-agents-sdk/.env.example

@@ -0,0 +1,4 @@
+# LLM key for local dev — the deployed agent uses guuey's managed broker instead.
+ANTHROPIC_API_KEY=
+# Only needed for the openai-agents-sdk template:
+OPENAI_API_KEY=

package/dist/templates/openai-agents-sdk/.mcp.json

@@ -0,0 +1 @@
+{ "mcpServers": { "ggui-dev": { "type": "http", "url": "https://mcp.ggui.ai/dev" } } }

package/dist/templates/openai-agents-sdk/README.md

@@ -0,0 +1,107 @@
+# agentic-app-template
+
+A guuey agentic app: a code-mode agent, a custom MCP server you can copy to
+add your own tools, and a `ggui` config for generative UI — all runnable
+locally with one command, and deployable to guuey with one more.
+
+## What got scaffolded
+
+```
+.
+├── guuey.json          # the deploy contract: agent framework/model, system prompt,
+│                        #   mcpServers (name → local dev port / hosted source), ggui config
+├── package.json         # agent deps + the pnpm workspace root (workspaces: mcps/*, web)
+├── src/worker.ts        # your agent code (code-mode worker); build emits ./guuey.worker.js
+├── prompts/system.md    # system prompt, referenced from guuey.json#agent.systemPrompt.file
+├── mcps/todo/           # the "copy-me" custom MCP server — @modelcontextprotocol/sdk,
+│                         #   Streamable HTTP, in-memory todo list, port :6782
+├── ggui/                # ggui.json + blueprints/ + themes/ — generative-UI config.
+│                         #   `ggui serve` runs against this locally; it's pushed to your
+│                         #   deployed app's guuey-managed ggui instance on `guuey deploy`.
+├── web/                 # a small Vite SPA chat client — the local dev surface, and a
+│                         #   worked example of the bring-your-own-frontend path
+├── scripts/dev.mjs      # `pnpm dev` orchestrator — boots the whole local stack
+├── .env.example          # ANTHROPIC_API_KEY / OPENAI_API_KEY for local dev
+└── .mcp.json             # Claude Code convenience wiring (mcp.ggui.ai/dev)
+```
+
+The project root **is** the agent package — `guuey deploy` packs this directory
+directly as the deploy tarball, so `guuey.json` and `src/worker.ts` live at the top
+level rather than nested under a `servers/` or `apps/` folder.
+
+## Quick start
+
+```bash
+pnpm install
+cp .env.example .env.local   # done automatically on scaffold if .env.local is absent
+# set ANTHROPIC_API_KEY (or OPENAI_API_KEY, for the openai-agents-sdk template) in .env.local
+pnpm dev
+```
+
+`pnpm dev` (`scripts/dev.mjs`) boots five processes with prefixed, interleaved
+logs. Ctrl-C tears all of them down together.
+
+| process      | port  | what                                                         |
+| ------------ | ----- | ------------------------------------------------------------ |
+| `worker`     | —     | `tsup --watch` — rebuilds `guuey.worker.js` on every save    |
+| `guuey dev`  | :6790 | local router: spawns your worker per turn, streams SSE       |
+| `mcps/todo`  | :6782 | the example MCP server (copy this directory to add your own) |
+| `ggui serve` | :6781 | local generative-UI server, over `ggui/`                     |
+| `web`        | :6890 | the Vite chat SPA                                            |
+
+Open http://localhost:6890 to chat with your agent locally.
+
+## Local dev vs. deployed — what's different
+
+`guuey dev` is the open, local equivalent of the pod router that runs your
+worker in production. It mirrors the real spawn/stream contract closely — the
+same normalizer, the same SSE shape — but it deliberately cuts three corners
+that only matter once real users and real money are involved:
+
+- **No sandboxing.** Locally your worker runs as a plain child process — no
+  `bwrap`/gVisor isolation. In production every invocation runs inside a
+  gVisor-isolated pod.
+- **Permissive auth.** `ggui serve --dev-allow-all` accepts any bearer
+  locally. The deployed ggui instance enforces real auth.
+- **No metering or history.** Local runs aren't billed and aren't persisted.
+  Deployed conversations are metered and their history is written to
+  DynamoDB so users can resume a thread.
+
+None of this changes your code — `guuey.json` is the same file in both
+worlds; only how it's resolved differs (`guuey dev` points MCP server names
+at `localhost:<devPort>`, `guuey deploy` points them at the platform's
+federated URLs).
+
+## Deploying
+
+```bash
+guuey login    # device-flow auth; stores a token in ~/.guuey/auth.json
+guuey deploy   # ships everything
+```
+
+`guuey deploy` runs four legs, in order, so a hard failure aborts before
+anything user-visible changes:
+
+1. **MCP leg** — deploys each `hosted` entry under `guuey.json#agent.mcpServers`
+   (e.g. `mcps/todo`) as its own hosted MCP server (build → deploy → registry),
+   then writes the resulting server id back into `guuey.json`.
+2. **ggui asset leg** — pushes `ggui/` (ggui.json, blueprints, themes) to your
+   app's guuey-managed ggui instance.
+3. **Agent leg** — builds `src/worker.ts` into `guuey.worker.js`, packs the
+   project root, and deploys it as a gVisor-isolated, scale-to-zero pod.
+4. **Output** — prints your agent's endpoint URL and a Portal deep link.
+
+Re-running `guuey deploy` converges: unchanged pieces are skipped or reused,
+nothing is duplicated.
+
+## How people talk to your agent
+
+- **guuey Portal** — a Telegram-like agent App Store and universal chat
+  client. Once deployed, your agent is reachable from Portal with **zero
+  frontend code** — most builders never need to touch `web/` at all.
+- **`web/`** — ships anyway, because the local dev loop needs a chat surface,
+  and it's a worked example of the bring-your-own-frontend path if you want
+  to embed your agent somewhere Portal doesn't reach.
+- **Future: guuey widgets** — an embeddable web-chat widget for dropping
+  your agent into an existing site is planned as a separate feature; `web/`
+  is designed to make that graduation straightforward when it lands.

package/dist/templates/openai-agents-sdk/ggui/ggui.json

@@ -0,0 +1,15 @@
+{
+  "schema": "1",
+  "protocol": "draft-2026-06-12",
+  "app": {
+    "slug": "agentic-app-template",
+    "name": "agentic-app-template"
+  },
+  "generation": {
+    "model": "anthropic:claude-haiku-4-5-20251001"
+  },
+  "theme": {
+    "preset": "indigo",
+    "mode": "dark"
+  }
+}

package/dist/templates/openai-agents-sdk/guuey.json

@@ -0,0 +1,13 @@
+{
+  "schema": "1",
+  "agent": {
+    "mode": "code",
+    "framework": "openai-agents-sdk",
+    "model": "gpt-5.5",
+    "systemPrompt": { "file": "prompts/system.md" },
+    "mcpServers": {
+      "todo": { "kind": "hosted", "source": "./mcps/todo", "devPort": 6782 }
+    }
+  },
+  "ggui": { "configFile": "./ggui/ggui.json" }
+}

package/dist/templates/openai-agents-sdk/mcps/todo/Dockerfile

@@ -0,0 +1,46 @@
+# todo-mcp — guuey hosted MCP server image.
+#
+# Self-sufficient multi-stage build: `guuey mcp deploy` packs this directory
+# into a tarball and hands it straight to the builder with no external
+# pre-build step and no build args — this Dockerfile installs its own deps
+# and builds itself. (Different from guuey's own first-party MCP servers,
+# which use a "copy-prebuilt" pattern that expects `dist/` + `node_modules/`
+# to already exist before `docker build` runs — that pattern does not apply
+# to a standalone project like this one.)
+#
+# Build + run locally:
+#
+#   docker build -t todo-mcp .
+#   docker run -p 8080:8080 todo-mcp
+#   curl http://localhost:8080/health
+#
+# Deploy to guuey:
+#
+#   cd mcps/todo && guuey mcp deploy
+
+FROM node:22-slim AS build
+WORKDIR /app
+COPY package.json ./
+RUN npm install
+COPY tsconfig.json ./
+COPY src ./src
+RUN npm run build
+
+FROM node:22-slim
+WORKDIR /app
+ENV NODE_ENV=production
+# guuey's hosted-MCP runtime injects PORT=8080 and probes GET /health at that
+# port — this default matches so `docker run` alone also works.
+ENV PORT=8080
+
+COPY package.json ./
+RUN npm install --omit=dev
+COPY --from=build /app/dist ./dist
+
+USER node
+EXPOSE 8080
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+  CMD node -e "fetch('http://localhost:' + (process.env.PORT || 8080) + '/health').then(r => { if (!r.ok) throw 1 }).catch(() => process.exit(1))"
+
+CMD ["node", "dist/server.js"]

package/dist/templates/openai-agents-sdk/mcps/todo/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@agentic-app-template/todo-mcp",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx src/server.ts",
+    "build": "tsup src/server.ts --format esm -d dist",
+    "start": "node dist/server.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.0"
+  }
+}

package/dist/templates/openai-agents-sdk/mcps/todo/src/server.ts

@@ -0,0 +1,173 @@
+/**
+ * todo-mcp — the copy-me example MCP server for @agentic-app-template.
+ *
+ * A minimal, stateless Streamable HTTP MCP server: four tools over an
+ * in-memory todo list. Swap the `Map` for a real database when you outgrow
+ * a single replica; everything else (transport wiring, tool shape) stays
+ * the same.
+ *
+ * Transport pattern mirrors guuey's canonical hosted-MCP scaffold
+ * (`mcp-servers/_template` in the guuey monorepo): a fresh `McpServer` +
+ * `StreamableHTTPServerTransport` are created **per request** and torn down
+ * when the response closes. Stateless mode — the guuey proxy (and, locally,
+ * whatever MCP client you point at this server) handles sessions, so this
+ * server never keeps request state around between calls.
+ *
+ * Runtime contract when deployed via `guuey mcp deploy` (see mcps/todo's
+ * Dockerfile): the platform injects `PORT=8080` and probes `GET /health`
+ * for both liveness and readiness. Locally, `pnpm dev` runs this on
+ * `PORT=6782` (see ../../scripts/dev.mjs).
+ */
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { randomUUID } from "node:crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
+
+interface Todo {
+  id: string;
+  title: string;
+  done: boolean;
+}
+
+const todos = new Map<string, Todo>();
+
+const todoShape = {
+  id: z.string(),
+  title: z.string(),
+  done: z.boolean(),
+};
+
+/** Wrap a structured result as both `structuredContent` and a text block. */
+function toolResult(data: Record<string, unknown>) {
+  return {
+    structuredContent: data,
+    content: [{ type: "text" as const, text: JSON.stringify(data) }],
+  };
+}
+
+function buildMcpServer(): McpServer {
+  const server = new McpServer({
+    name: "todo-mcp",
+    version: "0.0.0",
+    description: "Create, list, toggle, and delete todos.",
+  });
+
+  server.registerTool(
+    "todo_list",
+    {
+      title: "List todos",
+      description: "List every todo, in creation order.",
+      inputSchema: {},
+      outputSchema: { todos: z.array(z.object(todoShape)) },
+    },
+    async () => toolResult({ todos: [...todos.values()] }),
+  );
+
+  server.registerTool(
+    "todo_create",
+    {
+      title: "Create todo",
+      description: "Create a new todo item.",
+      inputSchema: { title: z.string().min(1).describe("Todo title.") },
+      outputSchema: todoShape,
+    },
+    async ({ title }) => {
+      const todo: Todo = { id: randomUUID(), title, done: false };
+      todos.set(todo.id, todo);
+      // Spread into a fresh object literal — `toolResult` takes
+      // `Record<string, unknown>`, and a named interface like `Todo` isn't
+      // structurally assignable to that without an (unwanted) index
+      // signature of its own; a fresh literal is.
+      return toolResult({ ...todo });
+    },
+  );
+
+  server.registerTool(
+    "todo_toggle",
+    {
+      title: "Toggle todo",
+      description: "Flip a todo's done state.",
+      inputSchema: { id: z.string().describe("Todo id.") },
+      outputSchema: todoShape,
+    },
+    async ({ id }) => {
+      const todo = todos.get(id);
+      if (!todo) throw new Error(`todo not found: ${id}`);
+      todo.done = !todo.done;
+      return toolResult({ ...todo }); // fresh literal — see the create() comment above
+    },
+  );
+
+  server.registerTool(
+    "todo_delete",
+    {
+      title: "Delete todo",
+      description: "Delete a todo by id.",
+      inputSchema: { id: z.string().describe("Todo id.") },
+      outputSchema: { id: z.string(), deleted: z.boolean() },
+    },
+    async ({ id }) => {
+      const deleted = todos.delete(id);
+      return toolResult({ id, deleted });
+    },
+  );
+
+  return server;
+}
+
+const PORT = Number(process.env.PORT ?? 6782);
+
+const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+  if (req.method === "GET" && req.url === "/health") {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", server: "todo-mcp", version: "0.0.0" }));
+    return;
+  }
+
+  if (req.url !== "/mcp") {
+    res.writeHead(404, { "content-type": "application/json" }).end(
+      JSON.stringify({ error: "not found" }),
+    );
+    return;
+  }
+
+  // Fresh server + transport per request (stateless mode) — see module doc.
+  const mcp = buildMcpServer();
+  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+
+  res.on("close", () => {
+    transport.close().catch(() => undefined);
+    mcp.close().catch(() => undefined);
+  });
+
+  try {
+    await mcp.connect(transport);
+    await transport.handleRequest(req, res);
+  } catch (err) {
+    console.error("mcp_handle_failed", err);
+    if (!res.headersSent) {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32603, message: "Internal server error" },
+          id: null,
+        }),
+      );
+    }
+  }
+});
+
+httpServer.listen(PORT, () => {
+  console.log(`todo-mcp listening on :${PORT}`);
+});
+
+function shutdown(signal: string): void {
+  console.log(`${signal} received — shutting down`);
+  httpServer.close(() => process.exit(0));
+  // Force-exit if connections don't drain in time.
+  setTimeout(() => process.exit(1), 10_000).unref();
+}
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));

package/dist/templates/openai-agents-sdk/mcps/todo/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/templates/openai-agents-sdk/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "agentic-app-template",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "node scripts/dev.mjs",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@openai/agents": "^0.12.0",
+    "@guuey/config": "0.0.1",
+    "@guuey/worker": "0.0.1"
+  },
+  "devDependencies": {
+    "@guuey/cli": "0.0.1",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  }
+}