@aprovan/chat-backend 0.1.0-dev.4d82df8 → 0.1.0-dev.78c0b14

package/.turbo/turbo-build.log

@@ -9,12 +9,12 @@
 CLI Target: node20
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js      38.23 KB
-ESM dist/lambda.js     37.91 KB
-ESM dist/index.js.map  70.96 KB
-ESM dist/lambda.js.map 70.10 KB
-ESM ⚡️ Build success in 105ms
+ESM dist/index.js      32.89 KB
+ESM dist/lambda.js     32.57 KB
+ESM dist/index.js.map  59.37 KB
+ESM dist/lambda.js.map 58.51 KB
+ESM ⚡️ Build success in 123ms
 DTS Build start
-DTS ⚡️ Build success in 13399ms
-DTS dist/index.d.ts  2.67 KB
+DTS ⚡️ Build success in 14161ms
+DTS dist/index.d.ts  2.55 KB
 DTS dist/lambda.d.ts 171.00 B

package/dist/index.d.ts

@@ -38,7 +38,6 @@ declare const envSchema: z.ZodObject<{
     AWS_REGION: z.ZodDefault<z.ZodString>;
     WORKSPACE_TABLE_NAME: z.ZodString;
     MEMBERSHIPS_TABLE_NAME: z.ZodString;
-    USER_SESSIONS_TABLE_NAME: z.ZodString;
     OPENROUTER_SECRET_ARN: z.ZodString;
     GATEWAY_URL: z.ZodString;
     POSTHOG_PROJECT_API_KEY: z.ZodOptional<z.ZodString>;
@@ -52,7 +51,6 @@ declare const envSchema: z.ZodObject<{
     AWS_REGION: string;
     WORKSPACE_TABLE_NAME: string;
     MEMBERSHIPS_TABLE_NAME: string;
-    USER_SESSIONS_TABLE_NAME: string;
     OPENROUTER_SECRET_ARN: string;
     GATEWAY_URL: string;
     POSTHOG_HOST: string;
@@ -63,7 +61,6 @@ declare const envSchema: z.ZodObject<{
     COGNITO_CLIENT_ID: string;
     WORKSPACE_TABLE_NAME: string;
     MEMBERSHIPS_TABLE_NAME: string;
-    USER_SESSIONS_TABLE_NAME: string;
     OPENROUTER_SECRET_ARN: string;
     GATEWAY_URL: string;
     NODE_ENV?: "development" | "production" | "test" | undefined;

package/dist/index.js

@@ -2,7 +2,7 @@
 import { serve } from "@hono/node-server";
 
 // src/app.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono6 } from "hono";
 
 // src/middleware/auth.ts
 import { CognitoJwtVerifier } from "aws-jwt-verify";
@@ -32,11 +32,11 @@ var authMiddleware = async (c, next) => {
   }
 };
 
-// src/middleware/plan.ts
+// src/middleware/workspace.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();
+import { DynamoDBDocumentClient, QueryCommand } from "@aws-sdk/lib-dynamodb";
+var MEMBERSHIP_CACHE_TTL_MS = 3e5;
+var membershipCache = /* @__PURE__ */ new Map();
 var ddbClient = null;
 function getDdb() {
   if (!ddbClient) {
@@ -46,13 +46,57 @@ function getDdb() {
   }
   return ddbClient;
 }
+async function resolveWorkspaceId(userSub) {
+  const now = Date.now();
+  const cached = membershipCache.get(userSub);
+  if (cached && now - cached.fetchedAt < MEMBERSHIP_CACHE_TTL_MS) {
+    return cached.workspaceId;
+  }
+  const result = await getDdb().send(
+    new QueryCommand({
+      TableName: process.env["MEMBERSHIPS_TABLE_NAME"],
+      IndexName: "ByUserSub",
+      KeyConditionExpression: "userSub = :sub",
+      ExpressionAttributeValues: { ":sub": userSub },
+      Limit: 1
+    })
+  );
+  const item = result.Items?.[0];
+  if (!item) return null;
+  membershipCache.set(userSub, { workspaceId: item.workspaceId, fetchedAt: now });
+  return item.workspaceId;
+}
+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/middleware/plan.ts
+import { DynamoDBClient as DynamoDBClient2 } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient as DynamoDBDocumentClient2, GetCommand } from "@aws-sdk/lib-dynamodb";
+var WORKSPACE_CACHE_TTL_MS = 6e4;
+var workspaceCache = /* @__PURE__ */ new Map();
+var ddbClient2 = null;
+function getDdb2() {
+  if (!ddbClient2) {
+    ddbClient2 = DynamoDBDocumentClient2.from(
+      new DynamoDBClient2({ region: process.env["AWS_REGION"] })
+    );
+  }
+  return ddbClient2;
+}
 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(
+  const result = await getDdb2().send(
     new GetCommand({
       TableName: process.env["WORKSPACE_TABLE_NAME"],
       Key: { workspaceId }
@@ -79,116 +123,10 @@ var planMiddleware = async (c, next) => {
   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/health.ts
+import { Hono } from "hono";
+var health = new Hono();
+health.get("/health", (c) => c.json({ status: "ok" }));
 
 // src/routes/chat.ts
 import { withTracing } from "@posthog/ai";
@@ -199,7 +137,7 @@ import {
   stepCountIs,
   jsonSchema
 } from "ai";
-import { Hono } from "hono";
+import { Hono as Hono2 } from "hono";
 import { z } from "zod";
 
 // src/fallback-prompts.ts
@@ -553,14 +491,7 @@ var CHAT_PROMPT_ALLOWLIST = /* @__PURE__ */ new Set(["chat-patchwork-widget", "c
 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);
-}
+var sessionCache = /* @__PURE__ */ new Map();
 function gatewayUrl() {
   const url = process.env["GATEWAY_URL"];
   if (!url) throw new Error("GATEWAY_URL is not set");
@@ -569,22 +500,16 @@ function gatewayUrl() {
 async function getGatewaySession(claims, workspaceId, cognitoToken) {
   const sub = claims.sub;
   const now = Math.floor(Date.now() / 1e3);
-  const cached = sessionCache2.get(sub);
+  const cached = sessionCache.get(sub);
   if (cached && cached.expires_at > now + 60) {
     return cached;
   }
   const entry = await exchangeSession(cognitoToken, workspaceId, claims.exp);
-  sessionCache2.set(sub, entry);
+  sessionCache.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);
-  }
+  const res = await callAuthSessions(cognitoToken, workspaceId);
   if (res.status === 401) {
     const retryRes = await callAuthSessions(cognitoToken, workspaceId);
     if (!retryRes.ok) {
@@ -592,14 +517,6 @@ async function exchangeSession(cognitoToken, workspaceId, exp) {
     }
     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());
   }
@@ -616,8 +533,7 @@ async function callAuthSessions(cognitoToken, workspaceId) {
   });
 }
 function evictGatewaySession(sub) {
-  sessionCache2.delete(sub);
-  toolsCache.delete(sub);
+  sessionCache.delete(sub);
 }
 var GatewaySessionError = class extends Error {
   constructor(status, message) {
@@ -758,7 +674,6 @@ 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(),
@@ -778,7 +693,7 @@ var retryAtStartMiddleware = {
     }
   }
 };
-var chatRoute = new Hono();
+var chatRoute = new Hono2();
 async function fetchGatewayTools(gatewayUrl2, bearerToken) {
   const res = await fetch(`${gatewayUrl2}/tools`, {
     headers: { Authorization: `Bearer ${bearerToken}` }
@@ -824,16 +739,10 @@ chatRoute.post("/", async (c) => {
   if (!parsed.success) {
     return c.json({ error: "Invalid request body" }, 400);
   }
-  const { messages, model: requestedModel, prompt: promptBody } = parsed.data;
+  const { messages, 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);
@@ -851,18 +760,11 @@ chatRoute.post("/", async (c) => {
   }
   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);
-      }
+    gatewayTools = await fetchGatewayTools(gatewayUrl2, sessionToken).catch(
+      () => []
+    );
+    if (gatewayTools.length === 0) {
+      evictGatewaySession(claims.sub);
     }
   }
   const tools = sessionToken && gatewayUrl2 ? buildTools(gatewayTools, gatewayUrl2, sessionToken) : {};
@@ -878,7 +780,7 @@ chatRoute.post("/", async (c) => {
   });
   const apiKey = await getOpenRouterKey();
   const provider = createOpenRouterProvider(apiKey);
-  const modelId = requestedModel ?? workspace.limits.maxModels[0] ?? "openrouter/auto";
+  const modelId = workspace.limits.maxModels[0] ?? "openrouter/auto";
   const baseModel = provider(modelId);
   const phClient = getPostHogClient();
   const tracedModel = phClient && promptResult.source !== "code_fallback" ? withTracing(baseModel, phClient, {
@@ -906,14 +808,14 @@ chatRoute.post("/", async (c) => {
 // src/routes/edit.ts
 import { withTracing as withTracing2 } from "@posthog/ai";
 import { streamText as streamText2 } from "ai";
-import { Hono as Hono2 } from "hono";
+import { Hono as Hono3 } 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();
+var editRoute = new Hono3();
 editRoute.post("/", async (c) => {
   const body = await c.req.json().catch(() => null);
   const parsed = editBodySchema.safeParse(body);
@@ -943,19 +845,12 @@ editRoute.post("/", async (c) => {
   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
+// src/routes/services.ts
 import { Hono as Hono4 } from "hono";
-var proxy = new Hono4();
-proxy.post("/:ns/:proc{.*}", async (c) => {
+var services = new Hono4();
+services.get("/", 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;
@@ -968,34 +863,37 @@ proxy.post("/:ns/:proc{.*}", async (c) => {
     }
     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)
+  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);
   }
-  const responseData = await res.json();
-  return c.json(responseData, res.status);
+  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/services.ts
+// src/routes/proxy.ts
 import { Hono as Hono5 } from "hono";
-var services = new Hono5();
-services.get("/", async (c) => {
+var proxy = new Hono5();
+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;
@@ -1008,99 +906,31 @@ services.get("/", async (c) => {
     }
     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`, {
-    headers: { Authorization: `Bearer ${sessionToken}` }
+  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);
   }
-  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)
+  const responseData = await res.json();
+  return c.json(responseData, res.status);
 });
-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();
+  const app2 = new Hono6();
   app2.route("/", health);
   const api = app2.basePath("/api");
   api.use(authMiddleware, workspaceMiddleware, planMiddleware);
@@ -1108,27 +938,25 @@ function createChatApp() {
   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(),
+import { z as z3 } from "zod";
+var envSchema = z3.object({
+  NODE_ENV: z3.enum(["development", "production", "test"]).default("development"),
+  PORT: z3.coerce.number().default(3001),
+  COGNITO_USER_POOL_ID: z3.string().min(1),
+  COGNITO_CLIENT_ID: z3.string().min(1),
+  AWS_REGION: z3.string().default("us-east-1"),
+  WORKSPACE_TABLE_NAME: z3.string().min(1),
+  MEMBERSHIPS_TABLE_NAME: z3.string().min(1),
+  OPENROUTER_SECRET_ARN: z3.string().min(1),
+  GATEWAY_URL: z3.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")
+  POSTHOG_PROJECT_API_KEY: z3.string().optional(),
+  POSTHOG_PERSONAL_API_KEY: z3.string().optional(),
+  POSTHOG_HOST: z3.string().default("https://us.posthog.com")
 });
 function parseEnv(raw) {
   return envSchema.parse(raw);