@getjack/jack 0.1.33 → 0.1.35

package/src/mcp/tools/index.ts

@@ -26,6 +26,9 @@ import {
 	listDomains,
 	unassignDomain,
 } from "../../lib/services/domain-operations.ts";
+import { testEndpoint } from "../../lib/services/endpoint-test.ts";
+import { deleteProject } from "../../lib/services/project-delete.ts";
+import { getProjectEnvironment } from "../../lib/services/project-environment.ts";
 import { createStorageBucket } from "../../lib/services/storage-create.ts";
 import { deleteStorageBucket } from "../../lib/services/storage-delete.ts";
 import { getStorageBucketInfo } from "../../lib/services/storage-info.ts";
@@ -224,6 +227,18 @@ const RollbackProjectSchema = z.object({
 		.describe("Path to project directory (defaults to current directory)"),
 });
 
+const DeleteProjectSchema = z.object({
+	project_path: z
+		.string()
+		.optional()
+		.describe("Path to project directory (defaults to current directory)"),
+	export_database: z
+		.boolean()
+		.optional()
+		.default(false)
+		.describe("Export database to a SQL file before deletion"),
+});
+
 const ListDomainsSchema = z.object({});
 
 const ConnectDomainSchema = z.object({
@@ -281,6 +296,33 @@ const TestCronSchema = z.object({
 		.describe("Whether to trigger the cron handler on production (requires managed project)"),
 });
 
+const GetProjectEnvironmentSchema = z.object({
+	project_path: z
+		.string()
+		.optional()
+		.describe("Path to project directory (defaults to current directory)"),
+});
+
+const TestEndpointSchema = z.object({
+	project_path: z
+		.string()
+		.optional()
+		.describe("Path to project directory (defaults to current directory)"),
+	path: z.string().describe("URL path to test, e.g. /api/todos"),
+	method: z
+		.enum(["GET", "POST", "PUT", "PATCH", "DELETE"])
+		.optional()
+		.default("GET")
+		.describe("HTTP method"),
+	headers: z.record(z.string()).optional().describe("Request headers"),
+	body: z.string().optional().describe("Request body (JSON string for POST/PUT/PATCH)"),
+	include_logs: z
+		.boolean()
+		.optional()
+		.default(true)
+		.describe("Capture runtime logs during the request (managed mode only)"),
+});
+
 export function registerTools(server: McpServer, _options: McpServerOptions, debug: DebugLogger) {
 	// Register tool list handler
 	server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -423,6 +465,25 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 						},
 					},
 				},
+				{
+					name: "delete_project",
+					description:
+						"Permanently delete a project and all its resources (worker, database). This is irreversible. Optionally export the database to a SQL file before deletion.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							project_path: {
+								type: "string",
+								description: "Path to project directory (defaults to current directory)",
+							},
+							export_database: {
+								type: "boolean",
+								default: false,
+								description: "Export database to a SQL file before deletion",
+							},
+						},
+					},
+				},
 				{
 					name: "create_database",
 					description:
@@ -780,6 +841,63 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 						required: ["expression"],
 					},
 				},
+				{
+					name: "get_project_environment",
+					description:
+						"Get a consolidated snapshot of the project's runtime environment: deployed URL, bindings (D1, KV, R2, AI, Vectorize, Durable Objects), " +
+						"database schema with table definitions and row counts, cron schedules, environment variables, secret names, and configuration issues. " +
+						"Call this instead of making multiple separate calls to understand a project's full state.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							project_path: {
+								type: "string",
+								description: "Path to project directory (defaults to current directory)",
+							},
+						},
+					},
+				},
+				{
+					name: "test_endpoint",
+					description:
+						"Test a deployed endpoint by making an HTTP request and capturing the response with optional runtime logs. " +
+						"Use after deploying to verify changes work, or to debug API behavior. " +
+						"Returns the full response (status, headers, body) and any console.log output from the worker.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							project_path: {
+								type: "string",
+								description: "Path to project directory (defaults to current directory)",
+							},
+							path: {
+								type: "string",
+								description: "URL path to test, e.g. /api/todos",
+							},
+							method: {
+								type: "string",
+								enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+								default: "GET",
+								description: "HTTP method",
+							},
+							headers: {
+								type: "object",
+								additionalProperties: { type: "string" },
+								description: "Request headers",
+							},
+							body: {
+								type: "string",
+								description: "Request body (JSON string for POST/PUT/PATCH)",
+							},
+							include_logs: {
+								type: "boolean",
+								default: true,
+								description: "Capture runtime logs during the request (managed mode only)",
+							},
+						},
+						required: ["path"],
+					},
+				},
 			],
 		};
 	});
@@ -1156,6 +1274,48 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 					};
 				}
 
+				case "delete_project": {
+					const args = DeleteProjectSchema.parse(request.params.arguments ?? {});
+					const projectPath = args.project_path ?? process.cwd();
+
+					const wrappedDeleteProject = withTelemetry(
+						"delete_project",
+						async (projectDir: string, exportDatabase: boolean) => {
+							const result = await deleteProject(projectDir, { exportDatabase });
+
+							track(Events.PROJECT_DELETED, {
+								deploy_mode: result.deployMode,
+								database_deleted: result.databaseDeleted,
+								database_exported: result.databaseExportPath !== null,
+								platform: "mcp",
+							});
+
+							return {
+								project_name: result.projectName,
+								deploy_mode: result.deployMode,
+								worker_deleted: result.workerDeleted,
+								database_deleted: result.databaseDeleted,
+								database_name: result.databaseName,
+								database_export_path: result.databaseExportPath,
+								resource_results: result.resourceResults,
+								warnings: result.warnings,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedDeleteProject(projectPath, args.export_database ?? false);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
 				case "create_database": {
 					const args = CreateDatabaseSchema.parse(request.params.arguments ?? {});
 					const projectPath = args.project_path ?? process.cwd();
@@ -1961,6 +2121,117 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 					};
 				}
 
+				case "get_project_environment": {
+					const args = GetProjectEnvironmentSchema.parse(request.params.arguments ?? {});
+					const projectPath = args.project_path ?? process.cwd();
+
+					const wrappedGetProjectEnvironment = withTelemetry(
+						"get_project_environment",
+						async (projectDir: string) => {
+							const env = await getProjectEnvironment(projectDir);
+
+							track(Events.COMMAND_COMPLETED, {
+								command: "get_project_environment",
+								has_database: !!env.database,
+								binding_count:
+									(env.bindings.d1 ? 1 : 0) +
+									(env.bindings.r2?.length ?? 0) +
+									(env.bindings.kv?.length ?? 0) +
+									(env.bindings.ai ? 1 : 0) +
+									(env.bindings.vectorize?.length ?? 0) +
+									(env.bindings.durable_objects?.length ?? 0),
+								issue_count: env.issues.length,
+								platform: "mcp",
+							});
+
+							return env;
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedGetProjectEnvironment(projectPath);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
+				case "test_endpoint": {
+					const args = TestEndpointSchema.parse(request.params.arguments ?? {});
+					const projectPath = args.project_path ?? process.cwd();
+
+					const wrappedTestEndpoint = withTelemetry(
+						"test_endpoint",
+						async (
+							projectDir: string,
+							path: string,
+							method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE",
+							headers?: Record<string, string>,
+							body?: string,
+							includeLogs?: boolean,
+						) => {
+							const result = await testEndpoint({
+								projectDir,
+								path,
+								method,
+								headers,
+								body,
+								includeLogs,
+							});
+
+							track(Events.COMMAND_COMPLETED, {
+								command: "test_endpoint",
+								method,
+								status: result.response.status,
+								duration_ms: result.response.duration_ms,
+								log_count: result.logs.length,
+								platform: "mcp",
+							});
+
+							return result;
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedTestEndpoint(
+						projectPath,
+						args.path,
+						args.method,
+						args.headers,
+						args.body,
+						args.include_logs,
+					);
+
+					// Add notes for agents about log availability
+					const notes: string[] = [];
+					if (args.include_logs && result.logs.length === 0) {
+						const deployMode = await getDeployMode(projectPath);
+						if (deployMode !== "managed") {
+							notes.push(
+								"Runtime logs are only available for managed (Jack Cloud) projects. Use tail_logs with a managed project.",
+							);
+						}
+					}
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(
+									formatSuccessResponse(result, startTime, notes.length ? notes : undefined),
+									null,
+									2,
+								),
+							},
+						],
+					};
+				}
+
 				default:
 					throw new Error(`Unknown tool: ${toolName}`);
 			}

package/src/templates/index.ts

@@ -19,10 +19,12 @@ export const BUILTIN_TEMPLATES = [
 	"nextjs",
 	"saas",
 	"ai-chat",
+	"chat",
 	"semantic-search",
 	"nextjs-shadcn",
 	"nextjs-clerk",
 	"nextjs-auth",
+	"telegram-bot",
 ];
 
 /**
@@ -89,6 +91,7 @@ async function loadTemplate(name: string): Promise<Template> {
 		envVars?: Template["envVars"];
 		capabilities?: Template["capabilities"];
 		requires?: Template["requires"];
+		crons?: Template["crons"];
 		hooks?: Template["hooks"];
 		agentContext?: Template["agentContext"];
 		intent?: Template["intent"];
@@ -107,6 +110,7 @@ async function loadTemplate(name: string): Promise<Template> {
 		envVars: metadata.envVars,
 		capabilities: metadata.capabilities,
 		requires: metadata.requires,
+		crons: metadata.crons,
 		hooks: metadata.hooks,
 		agentContext: metadata.agentContext,
 		intent: metadata.intent,
@@ -246,6 +250,7 @@ async function fetchRemoteTemplate(identifier: string): Promise<Template | null>
 		envVars: metadata.envVars as Template["envVars"],
 		capabilities: metadata.capabilities as Template["capabilities"],
 		requires: metadata.requires as Template["requires"],
+		crons: metadata.crons as Template["crons"],
 		hooks: metadata.hooks as Template["hooks"],
 		agentContext: metadata.agentContext as Template["agentContext"],
 		intent: metadata.intent as Template["intent"],

package/src/templates/types.ts

@@ -35,6 +35,9 @@ export type HookAction =
 			onMissing?: "fail" | "prompt" | "generate";
 			promptMessage?: string;
 			generateCommand?: string;
+			perProject?: boolean; // Skip global secrets store — always prompt or generate fresh
+			validateCommand?: string; // Shell command to validate prompted value ({{value}} is substituted)
+			validateError?: string; // Error message shown when validation fails
 	  }
 	| {
 			action: "stripe-setup";
@@ -92,6 +95,7 @@ export interface Template {
 	envVars?: EnvVar[]; // environment variables (non-secret config)
 	capabilities?: Capability[]; // infrastructure requirements (deprecated, use requires)
 	requires?: ServiceTypeKey[]; // service requirements (DB, KV, CRON, QUEUE, STORAGE)
+	crons?: string[]; // cron expressions to auto-create (managed mode only)
 	description?: string; // for help text
 	hooks?: TemplateHooks;
 	agentContext?: AgentContext;

package/templates/AI-BINDINGS.md

@@ -2,17 +2,15 @@
 
 ## Quick Reference for Coding Agents
 
-**DO NOT add `[ai]` or `[[vectorize]]` bindings directly for jack cloud projects.**
+### AI — Uses Proxy
 
-Jack cloud uses metered proxies for AI and Vectorize calls. Use the patterns below:
-
-### AI Pattern
+AI uses a metered proxy (`__AI_PROXY`). Templates need a `jack-ai.ts` wrapper:
 
 ```typescript
 import { createJackAI } from "./jack-ai";
 
 function getAI(env: Env) {
-  if (env.__AI_PROXY && env.__JACK_PROJECT_ID && env.__JACK_ORG_ID) {
+  if (env.__AI_PROXY) {
     return createJackAI(env);
   }
   if (env.AI) {
@@ -26,81 +24,60 @@ const ai = getAI(env);
 const result = await ai.run("@cf/meta/llama-3.2-1b-instruct", { messages });
 ```
 
-### Vectorize Pattern
-
-```typescript
-import { createJackVectorize } from "./jack-vectorize";
+### Vectorize — Direct Binding (Metered via Code Injection)
 
-const INDEX_NAME = "my-vectors";
+Vectorize uses `env.VECTORS` directly. No wrapper needed. The control plane injects a metering
+layer at deploy time that wraps the binding before your code runs.
 
-function getVectorize(env: Env) {
-  if (env.__VECTORIZE_PROXY && env.__JACK_PROJECT_ID && env.__JACK_ORG_ID) {
-    return createJackVectorize(env, INDEX_NAME);
-  }
-  if (env.VECTORS) {
-    return env.VECTORS;
-  }
-  throw new Error("No Vectorize binding available");
-}
-
-// Usage:
-const vectors = getVectorize(env);
-const results = await vectors.query(embedding, { topK: 10 });
-await vectors.insert([{ id: "doc1", values: embedding, metadata: {} }]);
+```typescript
+// Just use env.VECTORS — metering happens automatically
+const results = await env.VECTORS.query(embedding, { topK: 10 });
+await env.VECTORS.insert([{ id: "doc1", values: embedding, metadata: {} }]);
 ```
 
-## Why This Pattern?
+**Do NOT create a vectorize wrapper.** The old `jack-vectorize.ts` proxy pattern is deprecated.
 
-Jack cloud is multi-tenant. All users share Cloudflare's AI quota (10k neurons/day). Without metering:
-- One user could exhaust the daily quota for everyone
-- No visibility into per-project usage
-- No ability to bill for AI usage
+## Why Different Patterns?
 
-The proxy:
-1. Checks per-project quota
-2. Logs usage to Analytics Engine
-3. Forwards to real AI binding
-4. Returns response unchanged
+- **AI** is a global shared service. The proxy enforces per-project quota (sync check before forwarding).
+- **Vectorize** is per-tenant (each project gets its own index). The control plane wraps `env.VECTORS` via code injection (`__jack_meter.mjs`) for async metering. No proxy needed.
 
 ## Environment Bindings
 
 ### Jack Cloud (Managed Deploy)
 
-Control plane injects these bindings:
-- `__AI_PROXY` - Service binding to jack-binding-proxy for AI
-- `__VECTORIZE_PROXY` - Service binding to jack-binding-proxy for Vectorize
-- `__JACK_PROJECT_ID` - Project ID for metering
-- `__JACK_ORG_ID` - Organization ID for billing
+Control plane injects:
+- `__AI_PROXY` — Service binding to jack-binding-proxy for AI (metering + quota)
+- `VECTORS` — Direct Vectorize binding to the project's own index
+- `__JACK_VECTORIZE_USAGE` — Analytics Engine binding for vectorize metering (injected, not visible to user code)
 
-`env.AI` and `env.VECTORS` are **NOT available** in jack cloud. Direct calls will fail.
+`env.AI` is **NOT available** in jack cloud (use `getAI()` helper). `env.VECTORS` **IS available** directly.
 
 ### Local Development
 
 wrangler.jsonc provides:
-- `AI` - Direct Cloudflare AI binding for local testing
-- `VECTORS` - Direct Vectorize binding for local testing
+- `AI` — Direct Cloudflare AI binding for local testing
+- `VECTORS` — Direct Vectorize binding for local testing
 
-The helper functions automatically use the right binding based on environment.
+The `getAI()` helper automatically uses the right binding. For vectorize, `env.VECTORS` works in both environments.
 
 ## Template Pattern
 
 ### AI Templates
 
-1. **src/jack-ai.ts** - Client wrapper (copy from ai-chat or semantic-search template)
+1. **src/jack-ai.ts** — Client wrapper (copy from ai-chat or semantic-search template)
 
 2. **Env interface** with optional bindings:
 ```typescript
 interface Env {
   AI?: Ai;                    // Local dev
   __AI_PROXY?: Fetcher;       // Jack cloud
-  __JACK_PROJECT_ID?: string; // Jack cloud
-  __JACK_ORG_ID?: string;     // Jack cloud
 }
 ```
 
 3. **getAI() helper** that handles both environments
 
-4. **wrangler.jsonc** with AI binding for local dev only:
+4. **wrangler.jsonc** with AI binding:
 ```jsonc
 {
   "ai": { "binding": "AI" }
@@ -109,21 +86,16 @@ interface Env {
 
 ### Vectorize Templates
 
-1. **src/jack-vectorize.ts** - Client wrapper (copy from semantic-search template)
-
-2. **Env interface** with optional bindings:
+1. **Env interface** with direct binding:
 ```typescript
 interface Env {
-  VECTORS?: VectorizeIndex;      // Local dev
-  __VECTORIZE_PROXY?: Fetcher;   // Jack cloud
-  __JACK_PROJECT_ID?: string;    // Jack cloud
-  __JACK_ORG_ID?: string;        // Jack cloud
+  VECTORS: VectorizeIndex;
 }
 ```
 
-3. **getVectorize() helper** that handles both environments
+2. **Use `env.VECTORS` directly** — no wrapper, no helper needed
 
-4. **wrangler.jsonc** with Vectorize binding for local dev only:
+3. **wrangler.jsonc** with Vectorize binding:
 ```jsonc
 {
   "vectorize": [{
@@ -136,8 +108,6 @@ interface Env {
 
 ## Error Handling
 
-Quota exceeded returns 429:
-
 ### AI Quota
 ```typescript
 try {
@@ -150,21 +120,9 @@ try {
 }
 ```
 
-### Vectorize Quota
-```typescript
-try {
-  const results = await vectors.query(embedding, { topK: 10 });
-} catch (error) {
-  if (error.code === "VECTORIZE_QUERY_QUOTA_EXCEEDED") {
-    // Query limit (33,000/day) reached
-    console.log(`Retry in ${error.resetIn} seconds`);
-  }
-  if (error.code === "VECTORIZE_MUTATION_QUOTA_EXCEEDED") {
-    // Mutation limit (10,000/day) reached
-    console.log(`Retry in ${error.resetIn} seconds`);
-  }
-}
-```
+### Vectorize
+
+Vectorize calls go directly to the binding. There is no sync quota enforcement — metering is async via Analytics Engine. If Cloudflare's own rate limits are hit, the binding returns standard errors.
 
 ## BYOC Mode
 
@@ -176,6 +134,6 @@ For Bring Your Own Cloud deployments:
 
 ## See Also
 
-- `/docs/internal/specs/binding-proxy-worker.md` - Full architecture spec
-- `apps/binding-proxy-worker/` - Proxy implementation
-- `apps/control-plane/src/deployment-service.ts` - Binding injection logic
+- `apps/binding-proxy-worker/` — AI proxy implementation
+- `apps/control-plane/src/metering-wrapper.ts` — Vectorize metering code injection
+- `apps/control-plane/src/deployment-service.ts` — Binding injection logic

package/templates/CLAUDE.md

@@ -26,7 +26,7 @@ const result = await env.AI.run(model, inputs);
 import { createJackAI } from "./jack-ai";
 
 function getAI(env: Env) {
-  if (env.__AI_PROXY && env.__JACK_PROJECT_ID && env.__JACK_ORG_ID) {
+  if (env.__AI_PROXY) {
     return createJackAI(env);
   }
   return env.AI;
@@ -114,6 +114,27 @@ Before shipping a new template:
 - [ ] Install time < 5s (cold cache + lockfile)
 - [ ] All scripts work without global tools except wrangler
 - [ ] `.gitignore` includes `.env`, `.dev.vars`, `.secrets.json`
+- [ ] Prebuilt builds without env vars: `bun run build` succeeds with zero secrets set
+- [ ] If template has `schema.sql`, verify it's included in prebuild output
+
+## Prebuild Compatibility (IMPORTANT)
+
+Templates are prebuilt at release time **without any env vars or secrets**. The prebuild runs `bun run build` in a clean environment. If the build depends on runtime env vars, it will fail silently (only discovered when someone runs `prebuild-templates.ts`).
+
+**Common failure:** A provider component (e.g., `ClerkProvider`, `AuthProvider`) in the root layout requires an API key at import time. Next.js tries to statically prerender pages and the provider throws because the key is missing.
+
+**Fix:** Add `export const dynamic = "force-dynamic"` to the root layout. This tells Next.js to skip static prerendering for all pages, deferring to runtime where env vars are available.
+
+```tsx
+// app/layout.tsx
+export const dynamic = "force-dynamic"; // Required: provider needs runtime env vars
+
+export default function RootLayout({ children }) {
+  return <SomeProvider>{children}</SomeProvider>;
+}
+```
+
+**General rule:** If a template imports any SDK/provider that reads `process.env` or `env.*` at initialization, that template's layout or pages must be force-dynamic to survive a zero-env-var prebuild.
 
 ## Placeholder System
 

package/templates/ai-chat/src/index.ts

@@ -1,30 +1,25 @@
+import { type Message, convertToCoreMessages, streamText } from "ai";
 import { Hono } from "hono";
-import { streamText, convertToCoreMessages, type Message } from "ai";
 import { createWorkersAI } from "workers-ai-provider";
 import { createJackAI } from "./jack-ai";
 
 interface Env {
 	AI?: Ai;
 	__AI_PROXY?: Fetcher;
-	__JACK_PROJECT_ID?: string;
-	__JACK_ORG_ID?: string;
 	ASSETS: Fetcher;
 	DB: D1Database;
 }
 
 function getAI(env: Env) {
-	if (env.__AI_PROXY && env.__JACK_PROJECT_ID && env.__JACK_ORG_ID) {
-		return createJackAI(
-			env as Required<
-				Pick<Env, "__AI_PROXY" | "__JACK_PROJECT_ID" | "__JACK_ORG_ID">
-			>,
-		);
+	if (env.__AI_PROXY) {
+		return createJackAI(env as Pick<Env, "__AI_PROXY"> & { __AI_PROXY: Fetcher });
 	}
 	if (env.AI) return env.AI;
 	throw new Error("No AI binding available");
 }
 
-const SYSTEM_PROMPT = `You are a helpful AI assistant. Be concise, friendly, and helpful. Keep responses short unless detail is needed.`;
+const SYSTEM_PROMPT =
+	"You are a helpful AI assistant. Be concise, friendly, and helpful. Keep responses short unless detail is needed.";
 
 // Rate limiting
 const RATE_LIMIT = 10;
@@ -74,16 +69,14 @@ app.post("/api/chat", async (c) => {
 		messages: Message[];
 		chatId?: string;
 	}>();
-	if (!messages || !Array.isArray(messages)) {
+	if (!messages || !Array.isArray(messages) || messages.length === 0) {
 		return c.json({ error: "Invalid request." }, 400);
 	}
 
 	// Save user message to DB if we have a chatId
 	const lastUserMsg = messages.findLast((m: Message) => m.role === "user");
 	if (chatId && lastUserMsg) {
-		await c.env.DB.prepare(
-			"INSERT INTO messages (id, chat_id, role, content) VALUES (?, ?, ?, ?)",
-		)
+		await c.env.DB.prepare("INSERT INTO messages (id, chat_id, role, content) VALUES (?, ?, ?, ?)")
 			.bind(
 				crypto.randomUUID(),
 				chatId,

package/templates/ai-chat/src/jack-ai.ts

@@ -10,8 +10,6 @@
  *
  * interface Env {
  *   __AI_PROXY: Fetcher;        // Service binding to binding-proxy worker
- *   __JACK_PROJECT_ID: string;  // Injected by control plane
- *   __JACK_ORG_ID: string;      // Injected by control plane
  * }
  *
  * export default {
@@ -29,8 +27,6 @@
 
 interface JackAIEnv {
 	__AI_PROXY: Fetcher;
-	__JACK_PROJECT_ID: string;
-	__JACK_ORG_ID: string;
 }
 
 /**
@@ -56,8 +52,6 @@ export function createJackAI(env: JackAIEnv): {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
-					"X-Jack-Project-ID": env.__JACK_PROJECT_ID,
-					"X-Jack-Org-ID": env.__JACK_ORG_ID,
 				},
 				body: JSON.stringify({ model, inputs, options }),
 			});