docs(cookbook): Cookbook section + Daytona recipe + skill (OSS-222) (CopilotKit#5087)

## Summary
- New top-level **Cookbook** docs section with a small landing page,
added both as a top-level nav tab (next to Learn) and as a sidebar
section under Documentation. First recipe wires CopilotKit's Built-in
Agent up with a `runCode` server tool that executes Python, TypeScript,
or JavaScript in an isolated [Daytona](https://www.daytona.io) sandbox
and returns stdout to chat.
- New **`copilotkit-daytona` Agent Skill**
(`skills/copilotkit-daytona/`) — `SKILL.md` + `assets/` + `references/`
+ `eval.yaml` + a workspace fixture, mirroring
`skills/copilotkit-setup`. The skill's reference doc deliberately points
at Daytona's maintained sources (`llms.txt`, the dashboard limits page,
the official `daytona` Agent Skill, and the Daytona MCP server) rather
than duplicating a hand-copied SDK surface that would rot.
- Fixes a stale `learn/meta.json` link that pointed at
`../direct-to-llm/cookbook/state-machine` (target no longer exists).

Closes OSS-222.

## Test plan
- [x] `next build` compiles `/cookbook` and `/cookbook/daytona` as
static routes; OG images emit for both.
- [x] Broken-link checker shows no new broken links relative to `main`.
- [x] Cookbook appears as a top-level nav tab next to Learn, and as a
section in the Documentation sidebar.
- [x] Recipe code validated end-to-end on a deployed Railway app against
published `@copilotkit/runtime@1.58.0`: agent invokes `runCode`, a real
Daytona sandbox executes both Python and JavaScript snippets, output
round-trips through the chat (unique-token proof).

## Notes (out of scope, separate follow-ups)
- The Built-in Agent **quickstart** doc shows a v1 `<CopilotKit>`
provider mixed with v2 `<CopilotSidebar>`; the v2 demos use the all-v2
stack (`CopilotKitProvider` + `useSingleEndpoint` +
`createCopilotEndpointSingleRoute`). Worth a doc reconciliation in a
separate PR.
- The Vercel AI SDK emits *"System messages in the prompt or messages
fields…"* when the agent runs — it originates inside `BuiltInAgent`'s
call construction (passes system content via `messages` rather than the
SDK's `system` option). Benign, but a CopilotKit runtime improvement
worth filing separately.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: contextablemark

.github/config-allowlist.txt

@@ -34,6 +34,7 @@ examples/showcases/banking/next.config.mjs
 examples/showcases/chatkit-studio/apps/playground/next.config.ts
 examples/showcases/chatkit-studio/apps/studio/next.config.ts
 examples/showcases/chatkit-studio/apps/world/next.config.ts
+examples/showcases/daytona-runcode/next.config.ts
 examples/showcases/deep-agents-finance-erp/next.config.ts
 examples/showcases/deep-agents-job-search/next.config.ts
 examples/showcases/deep-agents/next.config.ts

examples/showcases/daytona-runcode/.gitignore

@@ -0,0 +1,4 @@
+node_modules
+.next
+.env
+.env.local

examples/showcases/daytona-runcode/README.md

@@ -0,0 +1,51 @@
+# CopilotKit × Daytona — `runCode` showcase
+
+The deployable demo behind the [Daytona cookbook recipe](../../../showcase/shell-docs/src/content/docs/cookbook/daytona.mdx).
+A minimal CopilotKit **Built-in Agent** app whose only added capability is a `runCode` server tool that executes
+Python / TypeScript / JavaScript inside an isolated [Daytona](https://www.daytona.io) sandbox and streams the
+result back to the chat — with a custom `useRenderTool` card (fixed-height streaming code pane with
+syntax highlighting and a fixed-height result pane).
+
+## What's inside
+
+- `app/api/copilotkit-single/route.ts` — the recipe's `runCode` tool wired into a `BuiltInAgent` on
+  `createCopilotEndpointSingleRoute`. Pure recipe code (Python/TS/JS via `daytona.create({ language })`).
+- `app/page.tsx` — `CopilotKitProvider` + `CopilotSidebar` + a `useRenderTool({ name: "runCode" })`
+  renderer using `react-syntax-highlighter` (Prism + `vscDarkPlus`, mirroring
+  `@copilotkit/react-ui`'s own `CodeBlock`).
+- A system prompt that tells the agent the tool result is rendered directly to the user, so it
+  doesn't restate stdout in chat text.
+
+## Prerequisites
+
+- Node 18+
+- An OpenAI API key (`OPENAI_API_KEY`) — the recipe defaults to `openai:gpt-5.4-mini`, overridable via
+  the `MODEL` env var.
+- A Daytona API key (`DAYTONA_API_KEY`) — create one in the
+  [Daytona dashboard](https://app.daytona.io/dashboard/keys).
+
+## Run locally
+
+```bash
+npm install
+echo "OPENAI_API_KEY=sk-…"      > .env.local
+echo "DAYTONA_API_KEY=…"       >> .env.local
+npm run dev   # http://localhost:3000
+```
+
+Open the page, click into the sidebar chat, and ask something like:
+
+> Run a Python snippet that prints the first 10 Fibonacci numbers.
+
+> Run JavaScript that logs Date.now().
+
+## Notes
+
+- This is a **standalone npm project** — intentionally not in the monorepo's `pnpm-workspace.yaml`.
+  `npm install` here installs against published `@copilotkit/*@1.58.0`, which is the same surface the
+  recipe targets.
+- `new Daytona()` throws at module load if `DAYTONA_API_KEY` is missing, so the app won't boot without
+  it. That's by design — the key is required, not optional.
+- For arbitrary languages beyond Python/TS/JS, swap `sandbox.process.codeRun` for
+  `sandbox.process.executeCommand(...)` and optionally use a custom Daytona `Image` with the toolchain
+  preinstalled. See the recipe's _Going further_ section.

examples/showcases/daytona-runcode/app/api/copilotkit-single/route.ts

@@ -0,0 +1,62 @@
+import {
+  CopilotRuntime,
+  InMemoryAgentRunner,
+  createCopilotEndpointSingleRoute,
+  BuiltInAgent,
+  defineTool,
+} from "@copilotkit/runtime/v2";
+import { Daytona } from "@daytonaio/sdk";
+import { handle } from "hono/vercel";
+import { z } from "zod";
+
+// --- The cookbook recipe: a server tool that runs code in a Daytona sandbox ---
+const daytona = new Daytona(); // reads DAYTONA_API_KEY
+
+const runCode = defineTool({
+  name: "runCode",
+  description:
+    "Execute code in an isolated Daytona sandbox and return its output.",
+  parameters: z.object({
+    code: z.string().describe("The code to run in the sandbox"),
+    language: z
+      .enum(["python", "typescript", "javascript"])
+      .default("python")
+      .describe("Language runtime for the code"),
+  }),
+  execute: async ({ code, language }) => {
+    const sandbox = await daytona.create({ language });
+    try {
+      const res = await sandbox.process.codeRun(code);
+      return { stdout: res.result, exitCode: res.exitCode };
+    } finally {
+      await sandbox.delete();
+    }
+  },
+});
+
+const agent = new BuiltInAgent({
+  model: process.env.MODEL ?? "openai:gpt-5.4-mini",
+  prompt:
+    "You are a coding assistant. When the user asks you to run, execute, or compute " +
+    "something with code, use the runCode tool to run it in a Daytona sandbox. " +
+    "Default to Python unless told otherwise. " +
+    "IMPORTANT: the tool's output (stdout + exit code) is rendered directly to the user " +
+    "in a separate UI panel; the user can already see it. Do NOT repeat, restate, or " +
+    "include the stdout or the generated code in your reply. Acknowledge briefly (a single " +
+    "short sentence) or stay silent. Never reproduce content that already appears in the " +
+    "tool card.",
+  tools: [runCode],
+  maxSteps: 2,
+});
+
+const runtime = new CopilotRuntime({
+  agents: { default: agent },
+  runner: new InMemoryAgentRunner(),
+});
+
+const app = createCopilotEndpointSingleRoute({
+  runtime,
+  basePath: "/api/copilotkit-single",
+});
+
+export const POST = handle(app);

examples/showcases/daytona-runcode/app/layout.tsx

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+import "@copilotkit/react-core/v2/styles.css";
+
+export const metadata = {
+  title: "CopilotKit × Daytona",
+  description: "A built-in agent that runs code in Daytona sandboxes.",
+};
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en">
+      <body style={{ margin: 0 }}>{children}</body>
+    </html>
+  );
+}