@noodleseed/agent-kit 0.14.0 → 0.15.0

package/skills/claude-code/examples/food-ordering/vitest.config.ts

@@ -0,0 +1,30 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      '@noodleseed/one': new URL('../../packages/authoring/src/index.ts', import.meta.url).pathname,
+      '@noodle-borg/capabilities': new URL(
+        '../../packages/capabilities/src/index.ts',
+        import.meta.url,
+      ).pathname,
+      '@noodle-borg/compiler': new URL('../../packages/compiler/src/index.ts', import.meta.url)
+        .pathname,
+      '@noodle-borg/compute': new URL('../../packages/compute/src/index.ts', import.meta.url)
+        .pathname,
+      '@noodle-borg/connector-defs': new URL(
+        '../../packages/connector-defs/src/index.ts',
+        import.meta.url,
+      ).pathname,
+      '@noodle-borg/connector-http': new URL(
+        '../../packages/connector-http/src/index.ts',
+        import.meta.url,
+      ).pathname,
+      '@noodle-borg/runtime': new URL('../../packages/runtime/src/index.ts', import.meta.url)
+        .pathname,
+    },
+  },
+  test: {
+    include: ['test/**/*.test.ts'],
+  },
+});

package/skills/claude-code/examples/hello/README.md

@@ -0,0 +1,13 @@
+# hello — minimal TypeScript quickstart
+
+The smallest deployable Noodle app: a single `greet` tool authored in TypeScript with no
+connectors, secrets, flows, widgets, or handoff policy. It still uses the current server options form
+so new authors see where server-level branding belongs. Use it to smoke the author loop
+(`noodle validate` / `noodle dev`) or a first deploy.
+
+```sh
+noodle dev examples/hello/src/server.ts --app hello
+noodle deploy examples/hello/src/server.ts --org acme --app hello
+```
+
+It is also the fixture for `pnpm smoke:dev` and the e2e harness, so keep its tool surface stable.

package/skills/claude-code/examples/hello/noodle.json

@@ -0,0 +1,5 @@
+{
+  "entrypoint": "src/server.ts",
+  "name": "hello",
+  "template": "hello"
+}

package/skills/claude-code/examples/hello/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "hello",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run",
+    "validate": "noodle validate",
+    "dev": "noodle dev",
+    "deploy": "noodle deploy"
+  },
+  "devDependencies": {
+    "@noodleseed/one": "latest",
+    "vitest": "latest"
+  }
+}

package/skills/claude-code/examples/hello/src/server.ts

@@ -0,0 +1,29 @@
+import { server, tool, z } from '@noodleseed/one';
+
+export default server(
+  'hello',
+  {
+    title: 'Hello',
+    version: '1.0.0',
+    branding: {
+      name: 'Hello',
+      accent: '#1D9E75',
+      radius: 'md',
+      density: 'comfortable',
+    },
+  },
+  [
+    tool('greet', {
+      description: 'Greet someone by name.',
+      input: z.object({
+        name: z.string(),
+      }),
+      output: z.object({
+        message: z.string(),
+      }),
+      fulfil: ({ input }) => {
+        return { message: `Hello, ${input.name}!` };
+      },
+    }),
+  ],
+);

package/skills/claude-code/examples/hello/test/server.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import app from '../src/server.js';
+
+describe('hello example', () => {
+  it('exports a Noodle server definition', () => {
+    expect(typeof app.toManifest).toBe('function');
+  });
+});

package/skills/claude-code/examples/weather/README.md

@@ -0,0 +1,54 @@
+# Weather Briefing
+
+A single declarative tool that shows the runtime's breadth working together, with **no auth and no API
+keys**. The `weather_briefing` tool takes a city name and runs a **three-step flow**:
+
+Capability slots: HTTP connector authoring, ordered fulfilment flows, query/response mapping, and sandboxed
+compute.
+
+1. **`geo.search`** → geocode the city to coordinates (Open-Meteo Geocoding API)
+2. **`forecast.current`** → fetch current weather for those coordinates (Open-Meteo Forecast API)
+3. **`brief.summarize`** → derive a human-readable briefing in a **WASM/QuickJS compute sandbox**
+
+It exercises, in one TypeScript-authored app:
+
+- **Server-level branding** with semantic tokens carried through the runtime artifact for any generated
+  app surface.
+- **Ordered flow execution** with outputs threaded between steps (`${steps.geo.latitude}` → next step).
+- **Two HTTP connectors on two different hosts**, each with its own egress allowlist.
+- **Query parameters** (`query: [...]`) and a constant query baked into the path (`?current_weather=true`).
+- **Deep response mapping** with the `${...}` language (`${response.results[0].latitude}`,
+  `${response.current_weather.temperature}`).
+- **Sandboxed compute** (no network/fs/env/clock) turning raw numbers into conditions + advice.
+- **Typed input/output schemas** emitted as JSON Schema 2020-12.
+
+## Run it locally
+
+From the repo root, with the workspace built (`pnpm build`):
+
+```bash
+: # 1. boot the local loopback dev server
+node packages/cli/dist/cli.js dev examples/weather/src/server.ts --app weather
+
+: # 2. in another shell, call the printed local endpoint
+URL=http://127.0.0.1:<port>/o/local/weather/dev/mcp
+curl -s "$URL" \
+  -H 'content-type: application/json' \
+  -H 'accept: application/json, text/event-stream' \
+  -H 'mcp-protocol-version: 2025-11-25' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"weather_briefing","arguments":{"city":"Paris"}}}'
+```
+
+Example result (live data, abbreviated):
+
+```json
+{
+  "place": "Paris", "country": "France",
+  "temperature_c": 25.1, "windspeed_kmh": 8.3,
+  "conditions": "overcast",
+  "headline": "Paris, France: 25°C, overcast.",
+  "advice": "Comfortable conditions — no special prep needed."
+}
+```
+
+Try other cities (`Reykjavik`, `Singapore`, `Denver`) to see the conditions and advice change.

package/skills/claude-code/examples/weather/noodle.json

@@ -0,0 +1,4 @@
+{
+  "entrypoint": "src/server.ts",
+  "name": "weather"
+}

package/skills/claude-code/examples/weather/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "weather",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run",
+    "validate": "noodle validate",
+    "dev": "noodle dev",
+    "deploy": "noodle deploy"
+  },
+  "devDependencies": {
+    "@noodleseed/one": "latest",
+    "vitest": "latest"
+  }
+}

package/skills/claude-code/examples/weather/src/server.ts

@@ -0,0 +1,190 @@
+import { connector, server, tool, z } from '@noodleseed/one';
+
+// The same Weather Briefing server, authored in TypeScript with the Noodle authoring SDK.
+//
+// The SDK owns the *manifest*: the tool, its Zod-typed input/output schemas, and the flow — which you
+// write as ordinary code in `fulfil` and the SDK records symbolically into ordered steps.
+//
+// HTTP and compute connectors are authored here too, so the public developer entrypoint is one
+// self-contained server.ts. The SDK still compiles this to internal manifest/catalog data for the runtime.
+
+const geocoding = connector('open_meteo_geocoding')
+  .version('1.0.0')
+  .http({
+    baseUrl: 'https://geocoding-api.open-meteo.com',
+    allowedOrigins: ['https://geocoding-api.open-meteo.com'],
+    operations: {
+      search: {
+        type: 'read',
+        method: 'GET',
+        path: '/v1/search',
+        query: ['name'],
+        input: { name: { type: 'string', required: true } },
+        output: {
+          latitude: { type: 'number', required: true },
+          longitude: { type: 'number', required: true },
+          place: { type: 'string' },
+          country: { type: 'string' },
+        },
+        response: {
+          latitude: '${response.results[0].latitude}',
+          longitude: '${response.results[0].longitude}',
+          place: '${response.results[0].name}',
+          country: '${response.results[0].country}',
+        },
+      },
+    },
+  });
+
+const forecast = connector('open_meteo_forecast')
+  .version('1.0.0')
+  .http({
+    baseUrl: 'https://api.open-meteo.com',
+    allowedOrigins: ['https://api.open-meteo.com'],
+    operations: {
+      current: {
+        type: 'read',
+        method: 'GET',
+        path: '/v1/forecast?current_weather=true',
+        query: ['latitude', 'longitude'],
+        input: {
+          latitude: { type: 'number', required: true },
+          longitude: { type: 'number', required: true },
+        },
+        output: {
+          temperature: { type: 'number' },
+          windspeed: { type: 'number' },
+          weathercode: { type: 'number' },
+        },
+        response: {
+          temperature: '${response.current_weather.temperature}',
+          windspeed: '${response.current_weather.windspeed}',
+          weathercode: '${response.current_weather.weathercode}',
+        },
+      },
+    },
+  });
+
+const brief = connector('weather_brief')
+  .version('1.0.0')
+  .compute('summarize', {
+    type: 'read',
+    input: {
+      place: { type: 'string', required: true },
+      country: { type: 'string' },
+      temperature: { type: 'number', required: true },
+      windspeed: { type: 'number', required: true },
+      weathercode: { type: 'number', required: true },
+    },
+    output: {
+      conditions: { type: 'string', required: true },
+      headline: { type: 'string', required: true },
+      advice: { type: 'string', required: true },
+    },
+    // A real function — type-checked here, serialized to source and run in the sandbox. It must be
+    // self-contained: no imports, no closure over outer variables, synchronous.
+    run: (input) => {
+      const codes: Record<number, string> = {
+        0: 'clear sky',
+        1: 'mainly clear',
+        2: 'partly cloudy',
+        3: 'overcast',
+        45: 'fog',
+        48: 'depositing rime fog',
+        51: 'light drizzle',
+        53: 'moderate drizzle',
+        55: 'dense drizzle',
+        61: 'slight rain',
+        63: 'moderate rain',
+        65: 'heavy rain',
+        71: 'slight snow',
+        73: 'moderate snow',
+        75: 'heavy snow',
+        77: 'snow grains',
+        80: 'slight rain showers',
+        81: 'moderate rain showers',
+        82: 'violent rain showers',
+        85: 'slight snow showers',
+        86: 'heavy snow showers',
+        95: 'thunderstorm',
+        96: 'thunderstorm with hail',
+        99: 'thunderstorm with heavy hail',
+      };
+      const code = Number(input.weathercode);
+      const conditions = codes[code] || 'unknown conditions';
+      const temp = Math.round(Number(input.temperature));
+      const wind = Math.round(Number(input.windspeed));
+      const where = input.country ? `${input.place}, ${input.country}` : input.place;
+      const headline = `${where}: ${temp}°C, ${conditions}.`;
+      const tips: string[] = [];
+      if (temp <= 0) tips.push("bundle up, it's freezing");
+      else if (temp <= 10) tips.push('wear a warm coat');
+      else if (temp >= 28) tips.push("stay hydrated, it's hot");
+      if (code >= 95) tips.push('thunderstorms expected — seek shelter');
+      else if (code >= 71 && code <= 86 && code !== 80 && code !== 81 && code !== 82)
+        tips.push('snow — dress warm and tread carefully');
+      else if (code >= 51 && code <= 82) tips.push('bring an umbrella');
+      if (wind >= 30) tips.push('expect strong winds');
+      const advice = tips.length
+        ? `${tips.join('; ')}.`
+        : 'Comfortable conditions — no special prep needed.';
+      return { conditions, headline, advice };
+    },
+  });
+
+export default server(
+  'weather_briefing',
+  {
+    title: 'Weather Briefing',
+    version: '1.0.0',
+    use: { geo: geocoding, forecast, brief },
+    branding: {
+      name: 'Weather Briefing',
+      accent: '#0284C7',
+      radius: 'md',
+      density: 'comfortable',
+    },
+  },
+  [
+    tool('weather_briefing', {
+      description:
+        'Look up a city, fetch its current weather, and return a human-readable briefing. Runs a ' +
+        'three-step flow: geocode the city, fetch the forecast, then derive the briefing in a sandboxed compute step.',
+      input: z.object({
+        city: z.string(),
+      }),
+      output: z.object({
+        place: z.string(),
+        country: z.string(),
+        temperature_c: z.number(),
+        windspeed_kmh: z.number(),
+        conditions: z.string(),
+        headline: z.string(),
+        advice: z.string(),
+      }),
+      fulfil: ({ input, connectors }) => {
+        const located = connectors.geo.search({ name: input.city });
+        const weather = connectors.forecast.current({
+          latitude: located.latitude,
+          longitude: located.longitude,
+        });
+        const briefing = connectors.brief.summarize({
+          place: located.place,
+          country: located.country,
+          temperature: weather.temperature,
+          windspeed: weather.windspeed,
+          weathercode: weather.weathercode,
+        });
+        return {
+          place: located.place,
+          country: located.country,
+          temperature_c: weather.temperature,
+          windspeed_kmh: weather.windspeed,
+          conditions: briefing.conditions,
+          headline: briefing.headline,
+          advice: briefing.advice,
+        };
+      },
+    }),
+  ],
+);

package/skills/claude-code/examples/weather/test/server.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import app from '../src/server.js';
+
+describe('weather example', () => {
+  it('exports a Noodle server definition', () => {
+    expect(typeof app.toManifest).toBe('function');
+  });
+});

package/skills/claude-code/references/examples.md

@@ -1,15 +1,24 @@
 # Examples
 
-Flagship examples (one per capability). Each lives in the Noodle Seed repository under `examples/<name>/` (`server.ts`, `src/views/*.tsx`, `README.md`, and a `design/` folder for the design-first flagships). Read the matching example for the pattern you need; extend an existing flagship rather than inventing a new shape.
+Flagship examples, one per capability. The **bundled** rows ship inside this skill under `examples/<name>/` (the real `server.ts`, `src/views/*.tsx`, and — for the design-first flagships — a `design/` set); read them locally at the paths shown. The rest live only in the Noodle Seed repository under `examples/<name>/` on GitHub. Extend an existing flagship rather than inventing a new shape.
+
+## Bundled in this skill — read locally
+
+Paths are relative to this skill directory. Assets (images/fonts) are omitted from the bundle; fetch the full runnable example from the repository if you need them. Verify any edit with `noodle validate --json` then `noodle test --json`.
+
+| Example | Use when | Read |
+| :-- | :-- | :-- |
+| `hello` | Minimal TypeScript quickstart — a single tool, no connectors/widgets. | `examples/hello/src/server.ts` |
+| `weather` | HTTP connectors, multi-step flows, and the sandboxed compute connector. | `examples/weather/src/server.ts` |
+| `food-ordering` | Consumer ordering MCP App widgets, app-only helpers, cart state, assets, branding, and handoff. | `examples/food-ordering/src/server.ts` |
+| `acme-discovery` | Top-of-funnel discovery→handoff: a discovery carousel, a `create_handoff` deep link, and a design-first UX spec + wireframe. | `examples/acme-discovery/src/server.ts` + `design/` |
+| `acme-tasks` | A two-way productivity app designed around its top-3 prioritized flows (capture/prioritize/complete), with a design-first flow spec + wireframe. | `examples/acme-tasks/src/server.ts` + `design/` |
+| `acme-bistro` | End-to-end ordering with a payment-only handoff; ships a gold-standard `design/` set (UX doc, wireframe with compliance audit, API contract). | `examples/acme-bistro/src/server.ts` + `design/` |
+
+## In the repository only — `examples/<name>/` on GitHub
 
 | Example | Use when |
 | :-- | :-- |
-| `hello` | Minimal TypeScript quickstart — a single tool, no connectors/widgets. |
-| `weather` | HTTP connectors, multi-step flows, and the sandboxed compute connector. |
-| `food-ordering` | Consumer ordering MCP App widgets, app-only helpers, cart state, assets, branding, and handoff. |
-| `acme-discovery` | Top-of-funnel discovery→handoff: a discovery carousel, a `create_handoff` deep link, and a design-first UX spec + wireframe. |
-| `acme-tasks` | A two-way productivity app designed around its top-3 prioritized flows (capture/prioritize/complete), with a design-first flow spec + wireframe. |
-| `acme-bistro` | End-to-end ordering with a payment-only handoff; ships a gold-standard `design/` set (UX doc, wireframe with compliance audit, API contract). |
 | `customer-auth` | End-user (customer) auth via OIDC/Firebase bridge with delegated credentials. |
 | `stateful-draft` | Durable, caller-scoped widget state handles with optimistic revisions. |
 | `perplexity` | A real SaaS API with bearer auth and a managed `secret`. |

package/skills/codex/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: noodle-seed
 description: Use when building, validating, testing, deploying, or operating a local or hosted Noodle Seed MCP server or app authored in TypeScript with the noodle CLI.
-version: 0.14.0
+version: 0.15.0
 hash: e623fd6ca7caad0f
 ---
 

package/skills/codex/examples/acme-bistro/README.md

@@ -0,0 +1,51 @@
+# Acme Bistro — end-to-end ordering with payment-only handoff
+
+A Noodle MCP App for **Acme Bistro**, a fictional restaurant. It is the flagship for the **end-to-end
+transaction** pattern: the customer browses the menu and builds the order *in chat*, and the order
+completes in chat — only **payment** hands off, via a signed checkout deep link (the card never touches
+the app). It pairs a `toolWithWidget` menu/cart with `toolForWidget` cart helpers and a model-visible
+`create_checkout` tool backed by `handoff.allowedDomains`.
+
+Capability slot: **end-to-end in-chat transaction + payment-only handoff**, plus a worked **design-first**
+deliverable set (`design/` — a UX Document, a single-file HTML wireframe with an embedded OpenAI Apps SDK
+compliance audit, and a Recommended API contract). It sets the quality bar the `noodle-seed` skill's
+`references/experience-design.md` and `references/chatgpt-compliance.md` teach. (Distinct from
+`food-ordering`, which is the broad widget-composition proof; this one owns the design-first end-to-end +
+compliance exemplar.)
+
+## Design deliverables (the standard to match)
+
+- [`design/UX-Document.md`](design/UX-Document.md) — the house-style UX Document.
+- [`design/wireframe.html`](design/wireframe.html) — the single-file wireframe (open in a browser) with the
+  embedded OpenAI Apps SDK compliance audit.
+- [`design/api-contract.md`](design/api-contract.md) — the Recommended API shapes for the partner's kitchen/
+  ordering backend.
+
+## Local author loop
+
+```sh
+noodle validate
+noodle test
+noodle dev
+```
+
+In another terminal:
+
+```sh
+noodle tools list
+noodle tools call show_menu --args '{"customer":"Asha"}'
+noodle tools call create_checkout --args '{"customer":"Asha","cartToken":"stone_pizzax2-lemon_tartx1","total":36}'
+noodle check --target chatgpt
+```
+
+## Deploy
+
+```sh
+noodle link --org demo --app acme-bistro
+noodle deploy --access owner-only
+noodle open
+```
+
+This example has no connector secrets and does not include tokens, caller-key mechanisms, or
+`.env.noodle` values. The menu, prices, and URLs are fictional; payment is handled off-app on
+`acme.example`, never in chat.