@aprovan/chat-backend 0.1.0-dev.4d82df8

package/dist/index.js

@@ -0,0 +1,1158 @@
+// src/index.ts
+import { serve } from "@hono/node-server";
+
+// src/app.ts
+import { Hono as Hono7 } from "hono";
+
+// src/middleware/auth.ts
+import { CognitoJwtVerifier } from "aws-jwt-verify";
+var verifier = null;
+function getVerifier() {
+  if (!verifier) {
+    verifier = CognitoJwtVerifier.create({
+      userPoolId: process.env["COGNITO_USER_POOL_ID"],
+      clientId: process.env["COGNITO_CLIENT_ID"],
+      tokenUse: "access"
+    });
+  }
+  return verifier;
+}
+var authMiddleware = async (c, next) => {
+  const authHeader = c.req.header("Authorization");
+  if (!authHeader?.startsWith("Bearer ")) {
+    return c.json({ error: "Unauthorized" }, 401);
+  }
+  const token = authHeader.slice(7);
+  try {
+    const payload = await getVerifier().verify(token);
+    c.set("claims", payload);
+    return next();
+  } catch {
+    return c.json({ error: "Unauthorized" }, 401);
+  }
+};
+
+// src/middleware/plan.ts
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb";
+var WORKSPACE_CACHE_TTL_MS = 6e4;
+var workspaceCache = /* @__PURE__ */ new Map();
+var ddbClient = null;
+function getDdb() {
+  if (!ddbClient) {
+    ddbClient = DynamoDBDocumentClient.from(
+      new DynamoDBClient({ region: process.env["AWS_REGION"] })
+    );
+  }
+  return ddbClient;
+}
+async function getWorkspace(workspaceId) {
+  const now = Date.now();
+  const cached = workspaceCache.get(workspaceId);
+  if (cached && now - cached.fetchedAt < WORKSPACE_CACHE_TTL_MS) {
+    return cached.workspace;
+  }
+  const result = await getDdb().send(
+    new GetCommand({
+      TableName: process.env["WORKSPACE_TABLE_NAME"],
+      Key: { workspaceId }
+    })
+  );
+  if (!result.Item) return null;
+  const workspace = result.Item;
+  workspaceCache.set(workspaceId, { workspace, fetchedAt: now });
+  return workspace;
+}
+var planMiddleware = async (c, next) => {
+  const workspaceId = c.get("workspaceId");
+  const workspace = await getWorkspace(workspaceId);
+  if (!workspace) {
+    return c.json({ error: "Workspace not found" }, 404);
+  }
+  if ("chat" in workspace.features && !workspace.features.chat) {
+    return c.json(
+      { error: "Chat is not available on your current plan", plan: workspace.plan },
+      402
+    );
+  }
+  c.set("workspace", workspace);
+  return next();
+};
+
+// src/middleware/workspace.ts
+import { DynamoDBClient as DynamoDBClient3 } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient as DynamoDBDocumentClient3, QueryCommand } from "@aws-sdk/lib-dynamodb";
+
+// src/session.ts
+import { DynamoDBClient as DynamoDBClient2 } from "@aws-sdk/client-dynamodb";
+import {
+  DynamoDBDocumentClient as DynamoDBDocumentClient2,
+  GetCommand as GetCommand2,
+  PutCommand
+} from "@aws-sdk/lib-dynamodb";
+var SESSION_CACHE_TTL_MS = 15e3;
+var sessionCache = /* @__PURE__ */ new Map();
+var ddbClient2 = null;
+function getDdb2() {
+  if (!ddbClient2) {
+    ddbClient2 = DynamoDBDocumentClient2.from(
+      new DynamoDBClient2({ region: process.env["AWS_REGION"] })
+    );
+  }
+  return ddbClient2;
+}
+function tableName() {
+  return process.env["USER_SESSIONS_TABLE_NAME"];
+}
+async function getSessionWorkspaceId(userSub) {
+  const now = Date.now();
+  const cached = sessionCache.get(userSub);
+  if (cached && now - cached.fetchedAt < SESSION_CACHE_TTL_MS) {
+    return cached.activeWorkspaceId;
+  }
+  const result = await getDdb2().send(
+    new GetCommand2({
+      TableName: tableName(),
+      Key: { userSub }
+    })
+  );
+  const activeWorkspaceId = result.Item?.activeWorkspaceId ?? null;
+  sessionCache.set(userSub, { activeWorkspaceId, fetchedAt: now });
+  return activeWorkspaceId;
+}
+async function setSessionWorkspaceId(userSub, workspaceId) {
+  await getDdb2().send(
+    new PutCommand({
+      TableName: tableName(),
+      Item: {
+        userSub,
+        activeWorkspaceId: workspaceId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    })
+  );
+  sessionCache.set(userSub, {
+    activeWorkspaceId: workspaceId,
+    fetchedAt: Date.now()
+  });
+}
+
+// src/middleware/workspace.ts
+var MEMBERSHIP_CACHE_TTL_MS = 3e5;
+var membershipCache = /* @__PURE__ */ new Map();
+var ddbClient3 = null;
+function getDdb3() {
+  if (!ddbClient3) {
+    ddbClient3 = DynamoDBDocumentClient3.from(
+      new DynamoDBClient3({ region: process.env["AWS_REGION"] })
+    );
+  }
+  return ddbClient3;
+}
+async function listWorkspaceMemberships(userSub) {
+  const now = Date.now();
+  const cached = membershipCache.get(userSub);
+  if (cached && now - cached.fetchedAt < MEMBERSHIP_CACHE_TTL_MS) {
+    return cached.workspaceIds;
+  }
+  const result = await getDdb3().send(
+    new QueryCommand({
+      TableName: process.env["MEMBERSHIPS_TABLE_NAME"],
+      IndexName: "ByUserSub",
+      KeyConditionExpression: "userSub = :sub",
+      ExpressionAttributeValues: { ":sub": userSub }
+    })
+  );
+  const workspaceIds = (result.Items ?? []).map(
+    (item) => item.workspaceId
+  );
+  membershipCache.set(userSub, { workspaceIds, fetchedAt: now });
+  return workspaceIds;
+}
+async function resolveWorkspaceId(userSub) {
+  const [sessionWsId, workspaceIds] = await Promise.all([
+    getSessionWorkspaceId(userSub),
+    listWorkspaceMemberships(userSub)
+  ]);
+  if (workspaceIds.length === 0) return null;
+  if (sessionWsId && workspaceIds.includes(sessionWsId)) {
+    return sessionWsId;
+  }
+  return workspaceIds[0] ?? null;
+}
+var workspaceMiddleware = async (c, next) => {
+  const claims = c.get("claims");
+  const workspaceId = await resolveWorkspaceId(claims.sub);
+  if (!workspaceId) {
+    return c.json({ error: "No workspace membership" }, 403);
+  }
+  c.set("workspaceId", workspaceId);
+  return next();
+};
+
+// src/routes/chat.ts
+import { withTracing } from "@posthog/ai";
+import {
+  streamText,
+  convertToModelMessages,
+  wrapLanguageModel,
+  stepCountIs,
+  jsonSchema
+} from "ai";
+import { Hono } from "hono";
+import { z } from "zod";
+
+// src/fallback-prompts.ts
+var PATCHWORK_PROMPT = `
+You are a friendly assistant! When responding to the user, you _must_ respond with JSX files!
+
+Look at 'patchwork.compilers' to see what specific runtime components and libraries are supported. (e.g. '['@aprovan/patchwork-image-shadcn' supports React, Tailwind, & ShadCN components). If there are no compilers, respond as you normally would. If compilers are available, ALWAYS respond with a component following [Component Generation](#component-generation).
+
+Look at 'patchwork.services' to see what services are available for widgets to call. If services are listed, you can generate widgets that make service calls using global namespace objects.
+
+**IMPORTANT: If you need to discover available services or get details about a specific service, use the \`search_services\` tool.**
+
+## Component Generation
+
+Respond with code blocks using tagged attributes on the fence line. The \`note\` attribute (optional but encouraged) provides a brief description visible in the UI. The \`path\` attribute specifies the virtual file path.
+
+### Code Block Format
+
+\`\`\`tsx note="Main component" path="components/weather/main.tsx"
+export default function WeatherWidget() {
+  // component code
+}
+\`\`\`
+
+### Attribute Order
+Put \`note\` first so it's available soonest in streaming UI.
+
+### Multi-File Generation
+
+When generating complex widgets, you can output multiple files. Use the \`@/\` prefix for virtual file system paths. ALWAYS prefer to generate visible components before metadata.
+
+**Example multi-file widget:**
+
+\`\`\`json note="Widget configuration" path="components/dashboard/package.json"
+{
+  "description": "Interactive dashboard widget",
+  "patchwork": {
+    "inputs": {
+      "type": "object",
+      "properties": {
+        "title": { "type": "string" }
+      }
+    },
+    "services": {
+      "analytics": ["getMetrics", "getChartData"]
+    }
+  }
+}
+\`\`\`
+
+\`\`\`tsx note="Main widget component" path="components/dashboard/main.tsx"
+import { Card } from './Card';
+import { Chart } from './Chart';
+
+export default function Dashboard({ title = "Dashboard" }) {
+  return (
+    <div>
+      <h1>{title}</h1>
+      <Card />
+      <Chart />
+    </div>
+  );
+}
+\`\`\`
+
+\`\`\`tsx note="Card subcomponent" path="components/dashboard/Card.tsx"
+export function Card() {
+  return <div className="p-4 rounded border">Card content</div>;
+}
+\`\`\`
+
+### Requirements
+- DO think heavily about correctness of code and syntax
+- DO keep things simple and self-contained
+- ALWAYS include the \`path\` attribute specifying the file location.
+- ALWAYS use generic component/path names that is not dependent on arguments (e.g. 'dinner.tsx' not 'spaghetti.tsx')
+- ALWAYS output the COMPLETE code block with opening \`\`\`tsx and closing \`\`\` markers
+- Use \`note\` attribute to describe what each code block does (optional but encouraged)
+- NEVER truncate or cut off code - finish the entire component before stopping
+- If the component is complex, simplify it rather than leaving it incomplete
+- Do NOT include: a heading/title
+
+### Visual Design Guidelines
+Create professional, polished interfaces that present information **spatially** rather than as vertical lists:
+- Use **cards, grids, and flexbox layouts** to organize related data into visual groups
+- Leverage **icons** (from lucide-react) alongside text to communicate meaning at a glance
+- Apply **visual hierarchy** through typography scale, weight, and color contrast
+- Use **whitespace strategically** to create breathing room and separation
+- Prefer **horizontal arrangements** where data fits naturally (e.g., stats in a row, badges inline)
+- Group related metrics into **compact visual clusters** rather than separate line items
+- Use **subtle backgrounds, borders, and shadows** to define sections without heavy dividers
+
+### Root Element Constraints
+The component will be rendered inside a parent container that handles positioning. Your root element should:
+- \u2705 Use intrinsic sizing (let content determine dimensions)
+- \u2705 Handle internal padding (e.g., \`p-4\`, \`p-6\`)
+- \u274C NEVER add centering utilities (\`items-center\`, \`justify-center\`) to position itself
+- \u274C NEVER add viewport-relative sizing (\`min-h-screen\`, \`h-screen\`, \`w-screen\`)
+- \u274C NEVER add flex/grid on root just for self-centering
+
+### Using Services in Widgets (CRITICAL)
+
+**MANDATORY workflow - you must follow these steps IN ORDER:**
+
+1. **Use \`search_services\`** to discover the service schema
+2. **STOP. Make an actual call to the service tool itself** (e.g., \`weather_get_forecast\`, \`github_get_repo\`) with real arguments. This is NOT optional. Do NOT skip this step.
+3. **Observe the response** - verify it succeeded and note the exact data structure
+4. **Only then generate the widget** that fetches the same data at runtime
+
+**\`search_services\` is NOT a substitute for calling the actual service.** It only returns documentation. You MUST invoke the real service tool to validate your arguments work.
+
+**Tool naming:** Service tools use underscores, not dots. For example: \`weather_get_forecast\`, \`github_list_repos\`.
+
+**Example workflow for a weather widget:**
+\`\`\`
+Step 1: search_services({ query: "weather" })
+        \u2192 Learn that weather_get_current_conditions exists with params: { latitude, longitude }
+
+Step 2: weather_get_current_conditions({ latitude: 29.7604, longitude: -95.3698 })  \u2190 REQUIRED!
+        \u2192 Verify it returns { temp: 72, humidity: 65, ... }
+
+Step 3: Generate widget that calls weather.get_current_conditions at runtime
+\`\`\`
+
+**If you skip Step 2, you will generate broken widgets.** Arguments that look correct in the schema may fail at runtime due to validation rules, required formats, or service-specific constraints.
+
+**NEVER embed static data directly in the component.**
+
+\u274C **WRONG** - Embedding data directly:
+\`\`\`tsx path="components/weather/bad-example.tsx"
+// DON'T DO THIS - calling tool, then embedding the response as static data
+export default function WeatherWidget() {
+  // Static data embedded at generation time - BAD!
+  const weather = { temp: 72, condition: "sunny", humidity: 45 };
+  return <div>Temperature: {weather.temp}\xB0F</div>;
+}
+\`\`\`
+
+\u2705 **CORRECT** - Fetching data at runtime:
+\`\`\`tsx note="Weather widget with runtime data" path="components/weather/main.tsx"
+export default function WeatherWidget() {
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    // Fetch data at runtime - GOOD!
+    weather.get_forecast({ latitude: 48.8566, longitude: 2.3522 })
+      .then(setData)
+      .catch(setError)
+      .finally(() => setLoading(false));
+  }, []);
+
+  if (loading) return <Skeleton className="h-32 w-full" />;
+  if (error) return <Alert variant="destructive">{error.message}</Alert>;
+
+  return <div>Temperature: {data.temp}\xB0F</div>;
+}
+\`\`\`
+
+**Why this matters:**
+- Widgets with runtime service calls show **live data** that updates when refreshed
+- Static embedded data becomes **stale immediately** after generation
+- The proxy pattern allows widgets to be **reusable** across different contexts
+- Error handling and loading states improve **user experience**
+
+**Service call pattern:**
+\`\`\`tsx
+// Services are available as global namespace objects
+// Call format: namespace.procedure_name({ ...args })
+
+const [data, setData] = useState(null);
+const [loading, setLoading] = useState(true);
+const [error, setError] = useState(null);
+
+useEffect(() => {
+  serviceName.procedure_name({ param1: value1 })
+    .then(setData)
+    .catch(setError)
+    .finally(() => setLoading(false));
+}, [/* dependencies */]);
+\`\`\`
+
+**Required for service-using widgets:**
+- Always show loading indicators (Skeleton, Loader2 spinner, etc.)
+- Always handle errors gracefully with user-friendly messages
+- Use appropriate React hooks (useState, useEffect) for async data
+- Services are injected as globals - NO imports needed
+
+### Validating Service Calls (CRITICAL - READ CAREFULLY)
+
+**Calling \`search_services\` multiple times is NOT validation.** You must call the actual service tool.
+
+\u274C **WRONG workflow (will produce broken widgets):**
+\`\`\`
+1. search_services({ query: "weather" })     \u2190 Only gets schema
+2. search_services({ query: "location" })    \u2190 Still only schema
+3. Generate widget                           \u2190 BROKEN - never tested the actual service!
+\`\`\`
+
+\u2705 **CORRECT workflow:**
+\`\`\`
+1. search_services({ query: "weather" })           \u2190 Get schema
+2. weather_get_forecast({ latitude: 29.76, longitude: -95.37 })  \u2190 ACTUALLY CALL IT
+3. Observe response: { temp: 72, conditions: "sunny", ... }
+4. Generate widget that calls weather.get_forecast at runtime
+\`\`\`
+
+**The service tool (e.g., \`weather_get_forecast\`, \`github_list_repos\`) is a DIFFERENT tool from \`search_services\`.** You have access to both. Use both.
+
+**Only after a successful test call to the actual service should you generate the widget.**
+
+### Component Parameterization (IMPORTANT)
+
+**Widgets should accept props for dynamic values instead of hardcoding:**
+
+\u274C **WRONG** - Hardcoded values:
+\`\`\`tsx path="components/weather/bad-example.tsx"
+export default function WeatherWidget() {
+  // Location hardcoded - BAD!
+  const [lat, lon] = [48.8566, 2.3522]; // Paris
+  // ...
+}
+\`\`\`
+
+\u2705 **CORRECT** - Parameterized with props and defaults:
+\`\`\`tsx note="Parameterized weather widget" path="components/weather/main.tsx"
+interface WeatherWidgetProps {
+  location?: string;    // e.g., "Paris, France"
+  latitude?: number;    // Direct coordinates (optional)
+  longitude?: number;
+}
+
+export default function WeatherWidget({
+  location = "Paris, France",
+  latitude,
+  longitude
+}: WeatherWidgetProps) {
+  // Use provided coordinates or look up from location name
+  // ...
+}
+\`\`\`
+
+**Why parameterize:**
+- Components become **reusable** across different contexts
+- Users can **customize behavior** without editing code
+- Enables **composition** - parent components can pass different values
+- Supports **testing** with various inputs
+
+**What to parameterize:**
+- Location names, coordinates, IDs
+- Search queries and filters
+- Display options (count, format, theme)
+- API-specific identifiers (usernames, repo names, etc.)
+
+### Anti-patterns to Avoid
+- \u274C Bulleted or numbered lists of key-value pairs
+- \u274C Vertical stacks where horizontal layouts would fit
+- \u274C Plain text labels without visual treatment
+- \u274C Uniform styling that doesn't distinguish primary from secondary information
+- \u274C Wrapping components in centering containers (parent handles this)
+- \u274C **Embedding API response data directly in components instead of fetching at runtime**
+- \u274C **Calling a tool, then putting the response as static JSX/JSON in the generated code**
+- \u274C **Hardcoding values that should be component props**
+- \u274C **Calling \`search_services\` multiple times instead of calling the actual service tool**
+- \u274C **Generating a widget without first making a real call to the service with your intended arguments**
+- \u274C **Treating schema documentation as proof that a service call will work**
+- \u274C **Omitting the \`path\` attribute on code blocks**
+`;
+var EDIT_PROMPT = `
+You are editing an existing JSX component. The user will provide the current code and describe the changes they want.
+
+## Response Format
+
+Use code fences with tagged attributes. The \`note\` attribute (optional but encouraged) provides a brief description visible in the UI. The \`path\` attribute specifies the target file.
+
+\`\`\`diff note="Brief description of this change" path="@/components/Button.tsx"
+<<<<<<< SEARCH
+exact code to find
+=======
+replacement code
+>>>>>>> REPLACE
+\`\`\`
+
+### Attribute Order
+Put \`note\` first so it's available soonest in streaming UI.
+
+### Multi-File Edits
+When editing multiple files, use the \`path\` attribute with virtual paths (\`@/\` prefix for generated files):
+
+\`\`\`diff note="Update button handler" path="@/components/Button.tsx"
+<<<<<<< SEARCH
+onClick={() => {}}
+=======
+onClick={() => handleClick()}
+>>>>>>> REPLACE
+\`\`\`
+
+\`\`\`diff note="Add utility function" path="@/lib/utils.ts"
+<<<<<<< SEARCH
+export const formatDate = ...
+=======
+export const formatDate = ...
+
+export const handleClick = () => console.log('clicked');
+>>>>>>> REPLACE
+\`\`\`
+
+## Rules
+- SEARCH block must match the existing code EXACTLY (whitespace, indentation, everything)
+- You can include multiple diff blocks for multiple changes
+- Each diff block should have its own \`note\` attribute annotation
+- Keep changes minimal and targeted
+- Do NOT output the full file - only the diffs
+- If clarification is needed, ask briefly before any diffs
+
+## CRITICAL: Diff Marker Safety
+- NEVER include the strings "<<<<<<< SEARCH", "=======", or ">>>>>>> REPLACE" inside your replacement code
+- These are reserved markers for parsing the diff format
+- If you need to show diff-like content, use alternative notation (e.g., "// old code" / "// new code")
+- Malformed diff markers will cause the edit to fail
+
+## Summary
+After all diffs, provide a brief markdown summary of the changes made. Use formatting like:
+- **Bold** for emphasis on key changes
+- Bullet points for listing multiple changes
+- Keep it concise (2-4 lines max)
+- Do NOT include: a heading/title
+`;
+var PLAIN_PROMPT = `You are a helpful assistant.
+
+{{tool_docs}}`;
+var FALLBACK_PROMPTS = {
+  "chat-patchwork-widget": `---
+patchwork:
+  compilers: {{compilers}}
+---
+
+${PATCHWORK_PROMPT}
+
+{{tool_docs}}`,
+  "chat-plain": PLAIN_PROMPT,
+  "edit-patchwork-widget": `Current component code:
+\`\`\`tsx
+{{code}}
+\`\`\`
+
+${EDIT_PROMPT}`
+};
+var CHAT_PROMPT_ALLOWLIST = /* @__PURE__ */ new Set(["chat-patchwork-widget", "chat-plain"]);
+var EDIT_PROMPT_ID = "edit-patchwork-widget";
+
+// src/gateway-session.ts
+var sessionCache2 = /* @__PURE__ */ new Map();
+var toolsCache = /* @__PURE__ */ new Map();
+function getCachedTools(sub) {
+  return toolsCache.get(sub);
+}
+function setCachedTools(sub, tools) {
+  toolsCache.set(sub, tools);
+}
+function gatewayUrl() {
+  const url = process.env["GATEWAY_URL"];
+  if (!url) throw new Error("GATEWAY_URL is not set");
+  return url.replace(/\/$/, "");
+}
+async function getGatewaySession(claims, workspaceId, cognitoToken) {
+  const sub = claims.sub;
+  const now = Math.floor(Date.now() / 1e3);
+  const cached = sessionCache2.get(sub);
+  if (cached && cached.expires_at > now + 60) {
+    return cached;
+  }
+  const entry = await exchangeSession(cognitoToken, workspaceId, claims.exp);
+  sessionCache2.set(sub, entry);
+  return entry;
+}
+async function exchangeSession(cognitoToken, workspaceId, exp) {
+  let res;
+  try {
+    res = await callAuthSessions(cognitoToken, workspaceId);
+  } catch {
+    await new Promise((r) => setTimeout(r, 200));
+    res = await callAuthSessions(cognitoToken, workspaceId);
+  }
+  if (res.status === 401) {
+    const retryRes = await callAuthSessions(cognitoToken, workspaceId);
+    if (!retryRes.ok) {
+      throw new GatewaySessionError(retryRes.status, await retryRes.text());
+    }
+    return { token: cognitoToken, expires_at: exp };
+  }
+  if (res.status >= 500) {
+    await new Promise((r) => setTimeout(r, 200));
+    const retryRes = await callAuthSessions(cognitoToken, workspaceId);
+    if (!retryRes.ok) {
+      throw new GatewaySessionError(retryRes.status, await retryRes.text());
+    }
+    return { token: cognitoToken, expires_at: exp };
+  }
+  if (!res.ok) {
+    throw new GatewaySessionError(res.status, await res.text());
+  }
+  return { token: cognitoToken, expires_at: exp };
+}
+async function callAuthSessions(cognitoToken, workspaceId) {
+  return fetch(`${gatewayUrl()}/auth/sessions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${cognitoToken}`
+    },
+    body: JSON.stringify({ workspace_id: workspaceId })
+  });
+}
+function evictGatewaySession(sub) {
+  sessionCache2.delete(sub);
+  toolsCache.delete(sub);
+}
+var GatewaySessionError = class extends Error {
+  constructor(status, message) {
+    super(`Gateway session exchange failed (${status}): ${message}`);
+    this.status = status;
+    this.name = "GatewaySessionError";
+  }
+  status;
+};
+
+// src/posthog.ts
+import { Prompts } from "@posthog/ai";
+import { PostHog } from "posthog-node";
+var _client = null;
+var _prompts = null;
+function initPostHog(env3) {
+  if (!env3.POSTHOG_PROJECT_API_KEY || !env3.POSTHOG_PERSONAL_API_KEY) return;
+  _client = new PostHog(env3.POSTHOG_PROJECT_API_KEY, {
+    host: env3.POSTHOG_HOST,
+    personalApiKey: env3.POSTHOG_PERSONAL_API_KEY
+  });
+  _prompts = new Prompts({ posthog: _client });
+}
+async function getPrompt(name, cacheTtlSeconds = 300) {
+  const fallback = FALLBACK_PROMPTS[name] ?? "";
+  if (!_prompts) {
+    return { source: "code_fallback", prompt: fallback, name: void 0, version: void 0 };
+  }
+  return _prompts.get(name, { cacheTtlSeconds, fallback });
+}
+function compilePrompt(template, vars) {
+  if (_prompts) {
+    return _prompts.compile(template, vars);
+  }
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "");
+}
+function getPostHogClient() {
+  return _client;
+}
+
+// src/providers/openrouter.ts
+import {
+  SecretsManagerClient,
+  GetSecretValueCommand
+} from "@aws-sdk/client-secrets-manager";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+var secretsClient = null;
+var cachedKey = null;
+function getSecretsClient() {
+  if (!secretsClient) {
+    secretsClient = new SecretsManagerClient({
+      region: process.env["AWS_REGION"]
+    });
+  }
+  return secretsClient;
+}
+async function getOpenRouterKey() {
+  if (cachedKey) return cachedKey;
+  const result = await getSecretsClient().send(
+    new GetSecretValueCommand({
+      SecretId: process.env["OPENROUTER_SECRET_ARN"]
+    })
+  );
+  cachedKey = result.SecretString;
+  return cachedKey;
+}
+function createOpenRouterProvider(apiKey) {
+  return createOpenAICompatible({
+    name: "openrouter",
+    apiKey,
+    baseURL: "https://openrouter.ai/api/v1"
+  });
+}
+
+// src/tool-docs.ts
+var _cachedToolDocs = "";
+var _toolDocsCachedAt = 0;
+var TOOL_DOCS_TTL_MS = 6e4;
+async function getToolDocs(gateway) {
+  if (!gateway) return "";
+  const now = Date.now();
+  if (_cachedToolDocs && now - _toolDocsCachedAt < TOOL_DOCS_TTL_MS) {
+    return _cachedToolDocs;
+  }
+  const tools = await gateway.listTools();
+  _cachedToolDocs = renderToolDocs(tools);
+  _toolDocsCachedAt = now;
+  return _cachedToolDocs;
+}
+function renderToolDocs(tools) {
+  if (tools.length === 0) return "";
+  const byNamespace = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const existing = byNamespace.get(tool.namespace) ?? [];
+    existing.push(tool);
+    byNamespace.set(tool.namespace, existing);
+  }
+  const namespaces = [...byNamespace.keys()];
+  let doc = `## Services
+
+The following services are available for generated widgets to call:
+
+`;
+  for (const [ns, nsTools] of byNamespace) {
+    doc += `### \`${ns}\`
+`;
+    for (const tool of nsTools) {
+      doc += `- \`${ns}.${tool.name}()\``;
+      if (tool.description) doc += `: ${tool.description}`;
+      doc += "\n";
+    }
+    doc += "\n";
+  }
+  const firstNs = namespaces[0] ?? "service";
+  const firstTool = byNamespace.get(firstNs)?.[0]?.name ?? "example";
+  doc += `**Usage in widgets:**
+\`\`\`tsx
+// Services are available as global namespaces
+const result = await ${firstNs}.${firstTool}({ /* args */ });
+\`\`\`
+
+Make sure to handle loading states and errors when calling services.
+`;
+  return doc;
+}
+function makeHttpGatewayClient(gatewayUrl2) {
+  return {
+    async listTools() {
+      const res = await fetch(`${gatewayUrl2}/tools`);
+      if (!res.ok) throw new Error(`Gateway returned ${res.status}`);
+      return res.json();
+    }
+  };
+}
+
+// src/routes/chat.ts
+var chatBodySchema = z.object({
+  id: z.string(),
+  messages: z.array(z.any()),
+  trigger: z.string(),
+  model: z.string().optional(),
+  metadata: z.unknown().optional(),
+  prompt: z.object({
+    id: z.string(),
+    vars: z.object({
+      compilers: z.array(z.string()).optional()
+    }).optional()
+  }).optional()
+});
+var retryAtStartMiddleware = {
+  specificationVersion: "v3",
+  async wrapStream({ doStream }) {
+    try {
+      return await doStream();
+    } catch {
+      await new Promise((r) => setTimeout(r, 200));
+      return doStream();
+    }
+  }
+};
+var chatRoute = new Hono();
+async function fetchGatewayTools(gatewayUrl2, bearerToken) {
+  const res = await fetch(`${gatewayUrl2}/tools`, {
+    headers: { Authorization: `Bearer ${bearerToken}` }
+  });
+  if (!res.ok) return [];
+  const data = await res.json();
+  return data.tools ?? [];
+}
+function buildTools(gatewayTools, gatewayUrl2, bearerToken) {
+  const tools = {};
+  for (const t of gatewayTools) {
+    const toolKey = t.name.replace(/\./g, "_");
+    const rawSchema = t.inputSchema && typeof t.inputSchema === "object" ? t.inputSchema : { type: "object", properties: {} };
+    const parameters = jsonSchema(
+      rawSchema
+    );
+    const execute = async (args) => {
+      const res = await fetch(`${gatewayUrl2}/tools/${t.provider}/${t.operation}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${bearerToken}`
+        },
+        body: JSON.stringify(args)
+      });
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({ error: res.statusText }));
+        return { error: err.error ?? res.statusText };
+      }
+      return res.json();
+    };
+    tools[toolKey] = {
+      description: t.description ?? `Call ${t.name}`,
+      parameters,
+      execute
+    };
+  }
+  return tools;
+}
+chatRoute.post("/", async (c) => {
+  const body = await c.req.json().catch(() => null);
+  const parsed = chatBodySchema.safeParse(body);
+  if (!parsed.success) {
+    return c.json({ error: "Invalid request body" }, 400);
+  }
+  const { messages, model: requestedModel, prompt: promptBody } = parsed.data;
+  const claims = c.get("claims");
+  const workspaceId = c.get("workspaceId");
+  const workspace = c.get("workspace");
+  if (requestedModel !== void 0 && !workspace.limits.maxModels.includes(requestedModel)) {
+    return c.json(
+      { error: "Model not allowed on your current plan", model: requestedModel },
+      403
+    );
+  }
+  const promptId = promptBody?.id ?? "chat-patchwork-widget";
+  if (!CHAT_PROMPT_ALLOWLIST.has(promptId)) {
+    return c.json({ error: "Unknown prompt id" }, 400);
+  }
+  const gatewayUrl2 = process.env["GATEWAY_URL"]?.replace(/\/$/, "");
+  let sessionToken = null;
+  if (gatewayUrl2) {
+    const authHeader = c.req.header("Authorization") ?? "";
+    const cognitoToken = authHeader.replace(/^Bearer /, "");
+    try {
+      const session = await getGatewaySession(claims, workspaceId, cognitoToken);
+      sessionToken = session.token;
+    } catch {
+    }
+  }
+  let gatewayTools = [];
+  if (sessionToken && gatewayUrl2) {
+    const cached = getCachedTools(claims.sub);
+    if (cached) {
+      gatewayTools = cached;
+    } else {
+      gatewayTools = await fetchGatewayTools(gatewayUrl2, sessionToken).catch(
+        () => []
+      );
+      if (gatewayTools.length === 0) {
+        evictGatewaySession(claims.sub);
+      } else {
+        setCachedTools(claims.sub, gatewayTools);
+      }
+    }
+  }
+  const tools = sessionToken && gatewayUrl2 ? buildTools(gatewayTools, gatewayUrl2, sessionToken) : {};
+  const gatewayClient = gatewayUrl2 ? makeHttpGatewayClient(gatewayUrl2) : null;
+  const [promptResult, toolDocs] = await Promise.all([
+    getPrompt(promptId),
+    getToolDocs(gatewayClient).catch(() => "")
+  ]);
+  const compilers = (promptBody?.vars?.compilers ?? []).join(", ");
+  const systemPrompt = compilePrompt(promptResult.prompt, {
+    compilers,
+    tool_docs: toolDocs
+  });
+  const apiKey = await getOpenRouterKey();
+  const provider = createOpenRouterProvider(apiKey);
+  const modelId = requestedModel ?? workspace.limits.maxModels[0] ?? "openrouter/auto";
+  const baseModel = provider(modelId);
+  const phClient = getPostHogClient();
+  const tracedModel = phClient && promptResult.source !== "code_fallback" ? withTracing(baseModel, phClient, {
+    posthogDistinctId: claims.sub,
+    posthogProperties: {
+      $ai_prompt_name: promptResult.name,
+      $ai_prompt_version: promptResult.version
+    }
+  }) : baseModel;
+  const model = wrapLanguageModel({
+    model: tracedModel,
+    middleware: retryAtStartMiddleware
+  });
+  const result = streamText({
+    model,
+    system: systemPrompt,
+    messages: await convertToModelMessages(messages),
+    stopWhen: stepCountIs(workspace.limits.maxToolSteps),
+    maxOutputTokens: workspace.limits.maxTokensPerRequest,
+    tools
+  });
+  return result.toUIMessageStreamResponse();
+});
+
+// src/routes/edit.ts
+import { withTracing as withTracing2 } from "@posthog/ai";
+import { streamText as streamText2 } from "ai";
+import { Hono as Hono2 } from "hono";
+import { z as z2 } from "zod";
+var editBodySchema = z2.object({
+  code: z2.string(),
+  prompt: z2.string()
+});
+var MODEL_ID = "openrouter/auto";
+var editRoute = new Hono2();
+editRoute.post("/", async (c) => {
+  const body = await c.req.json().catch(() => null);
+  const parsed = editBodySchema.safeParse(body);
+  if (!parsed.success) {
+    return c.json({ error: "Invalid request body" }, 400);
+  }
+  const promptResult = await getPrompt(EDIT_PROMPT_ID);
+  const systemPrompt = compilePrompt(promptResult.prompt, {
+    code: parsed.data.code
+  });
+  const apiKey = await getOpenRouterKey();
+  const provider = createOpenRouterProvider(apiKey);
+  const baseModel = provider(MODEL_ID);
+  const phClient = getPostHogClient();
+  const model = phClient && promptResult.source !== "code_fallback" ? withTracing2(baseModel, phClient, {
+    posthogDistinctId: "chat-api",
+    posthogProperties: {
+      $ai_prompt_name: promptResult.name,
+      $ai_prompt_version: promptResult.version
+    }
+  }) : baseModel;
+  const result = streamText2({
+    model,
+    system: systemPrompt,
+    messages: [{ role: "user", content: parsed.data.prompt }]
+  });
+  return result.toTextStreamResponse();
+});
+
+// src/routes/health.ts
+import { Hono as Hono3 } from "hono";
+var health = new Hono3();
+health.get("/health", (c) => c.json({ status: "ok" }));
+
+// src/routes/proxy.ts
+import { Hono as Hono4 } from "hono";
+var proxy = new Hono4();
+proxy.post("/:ns/:proc{.*}", async (c) => {
+  const claims = c.get("claims");
+  const workspaceId = c.get("workspaceId");
+  const ns = c.req.param("ns");
+  const proc = c.req.param("proc");
+  const authHeader = c.req.header("Authorization");
+  const cognitoToken = authHeader.slice("Bearer ".length);
+  let sessionToken;
+  try {
+    const session = await getGatewaySession(claims, workspaceId, cognitoToken);
+    sessionToken = session.token;
+  } catch (err) {
+    if (err instanceof GatewaySessionError && err.status === 401) {
+      return c.json({ error: "Gateway session setup failed" }, 401);
+    }
+    return c.json({ error: "Failed to connect to gateway" }, 502);
+  }
+  let body = {};
+  try {
+    body = await c.req.json();
+  } catch {
+  }
+  const gatewayUrl2 = process.env["GATEWAY_URL"].replace(/\/$/, "");
+  const res = await fetch(`${gatewayUrl2}/tools/${ns}/${proc}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${sessionToken}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (res.status === 401) {
+    evictGatewaySession(claims.sub);
+    return c.json({ error: "Gateway authentication failed" }, 502);
+  }
+  const responseData = await res.json();
+  return c.json(responseData, res.status);
+});
+
+// src/routes/services.ts
+import { Hono as Hono5 } from "hono";
+var services = new Hono5();
+services.get("/", async (c) => {
+  const claims = c.get("claims");
+  const workspaceId = c.get("workspaceId");
+  const authHeader = c.req.header("Authorization");
+  const cognitoToken = authHeader.slice("Bearer ".length);
+  let sessionToken;
+  try {
+    const session = await getGatewaySession(claims, workspaceId, cognitoToken);
+    sessionToken = session.token;
+  } catch (err) {
+    if (err instanceof GatewaySessionError && err.status === 401) {
+      return c.json({ error: "Gateway session setup failed" }, 401);
+    }
+    return c.json({ error: "Failed to connect to gateway" }, 502);
+  }
+  const gatewayUrl2 = process.env["GATEWAY_URL"].replace(/\/$/, "");
+  const res = await fetch(`${gatewayUrl2}/tools`, {
+    headers: { Authorization: `Bearer ${sessionToken}` }
+  });
+  if (res.status === 401) {
+    evictGatewaySession(claims.sub);
+    return c.json({ error: "Gateway authentication failed" }, 502);
+  }
+  if (!res.ok) {
+    return c.json({ error: "Gateway tools fetch failed" }, 502);
+  }
+  const data = await res.json();
+  const serviceList = data.tools.map((t) => ({
+    namespace: t.provider,
+    name: t.name,
+    procedure: t.operation,
+    description: t.description ?? "",
+    parameters: t.inputSchema
+  }));
+  const namespaces = Array.from(new Set(data.tools.map((t) => t.provider)));
+  return c.json({ namespaces, services: serviceList });
+});
+
+// src/routes/workspaces.ts
+import { DynamoDBClient as DynamoDBClient4 } from "@aws-sdk/client-dynamodb";
+import { BatchGetCommand, DynamoDBDocumentClient as DynamoDBDocumentClient4 } from "@aws-sdk/lib-dynamodb";
+import { zValidator } from "@hono/zod-validator";
+import { Hono as Hono6 } from "hono";
+import { z as z3 } from "zod";
+var ddbClient4 = null;
+function getDdb4() {
+  if (!ddbClient4) {
+    ddbClient4 = DynamoDBDocumentClient4.from(
+      new DynamoDBClient4({ region: process.env["AWS_REGION"] })
+    );
+  }
+  return ddbClient4;
+}
+async function batchGetWorkspaces(workspaceIds) {
+  if (workspaceIds.length === 0) return [];
+  const tableName2 = process.env["WORKSPACE_TABLE_NAME"];
+  const result = await getDdb4().send(
+    new BatchGetCommand({
+      RequestItems: {
+        [tableName2]: { Keys: workspaceIds.map((id) => ({ workspaceId: id })) }
+      }
+    })
+  );
+  return result.Responses?.[tableName2] ?? [];
+}
+var workspacesRoute = new Hono6();
+workspacesRoute.get("/", async (c) => {
+  const claims = c.get("claims");
+  const userSub = claims.sub;
+  const [workspaceIds, activeWorkspaceId] = await Promise.all([
+    listWorkspaceMemberships(userSub),
+    getSessionWorkspaceId(userSub)
+  ]);
+  const workspaces = await batchGetWorkspaces(workspaceIds);
+  const effectiveActiveId = activeWorkspaceId && workspaceIds.includes(activeWorkspaceId) ? activeWorkspaceId : workspaceIds[0] ?? null;
+  const sorted = workspaceIds.map((id) => workspaces.find((w) => w.workspaceId === id)).filter((w) => w !== void 0);
+  return c.json({
+    workspaces: sorted.map((w) => ({
+      workspaceId: w.workspaceId,
+      name: w.name,
+      plan: w.plan,
+      active: w.workspaceId === effectiveActiveId
+    })),
+    activeWorkspaceId: effectiveActiveId
+  });
+});
+var setActiveSchema = z3.object({
+  workspaceId: z3.string().min(1)
+});
+workspacesRoute.put(
+  "/active",
+  zValidator("json", setActiveSchema),
+  async (c) => {
+    const claims = c.get("claims");
+    const userSub = claims.sub;
+    const { workspaceId } = c.req.valid("json");
+    const workspaceIds = await listWorkspaceMemberships(userSub);
+    if (!workspaceIds.includes(workspaceId)) {
+      return c.json({ error: "Not a member of this workspace" }, 403);
+    }
+    await setSessionWorkspaceId(userSub, workspaceId);
+    return c.json({ activeWorkspaceId: workspaceId });
+  }
+);
+
+// src/app.ts
+function createChatApp() {
+  const app2 = new Hono7();
+  app2.route("/", health);
+  const api = app2.basePath("/api");
+  api.use(authMiddleware, workspaceMiddleware, planMiddleware);
+  api.route("/chat", chatRoute);
+  api.route("/edit", editRoute);
+  api.route("/services", services);
+  api.route("/proxy", proxy);
+  api.route("/workspaces", workspacesRoute);
+  return app2;
+}
+
+// src/env.ts
+import { z as z4 } from "zod";
+var envSchema = z4.object({
+  NODE_ENV: z4.enum(["development", "production", "test"]).default("development"),
+  PORT: z4.coerce.number().default(3001),
+  COGNITO_USER_POOL_ID: z4.string().min(1),
+  COGNITO_CLIENT_ID: z4.string().min(1),
+  AWS_REGION: z4.string().default("us-east-1"),
+  WORKSPACE_TABLE_NAME: z4.string().min(1),
+  MEMBERSHIPS_TABLE_NAME: z4.string().min(1),
+  USER_SESSIONS_TABLE_NAME: z4.string().min(1),
+  OPENROUTER_SECRET_ARN: z4.string().min(1),
+  GATEWAY_URL: z4.string().url(),
+  // PostHog prompt management (optional — falls back to code prompts when absent)
+  POSTHOG_PROJECT_API_KEY: z4.string().optional(),
+  POSTHOG_PERSONAL_API_KEY: z4.string().optional(),
+  POSTHOG_HOST: z4.string().default("https://us.posthog.com")
+});
+function parseEnv(raw) {
+  return envSchema.parse(raw);
+}
+
+// src/lambda.ts
+import { streamHandle } from "hono/aws-lambda";
+var env = parseEnv(process.env);
+initPostHog(env);
+var app = createChatApp();
+var handler = streamHandle(app);
+
+// src/index.ts
+var env2 = parseEnv(process.env);
+initPostHog(env2);
+if (env2.NODE_ENV !== "test") {
+  const app2 = createChatApp();
+  serve({ fetch: app2.fetch, port: env2.PORT }, () => {
+    console.log(`Chat API listening on :${env2.PORT}`);
+  });
+}
+export {
+  createChatApp,
+  handler,
+  initPostHog
+};
+//# sourceMappingURL=index.js.map