@insforge/mcp 1.2.8 → 1.2.9

package/dist/{chunk-DZ5W3BSP.js → chunk-YH7HSQYJ.js}

@@ -41,17 +41,40 @@ ${JSON.stringify(data, null, 2)}`;
 
 // src/shared/usage-tracker.ts
 import fetch from "node-fetch";
+var PLATFORM_API_BASE = "https://api.insforge.dev";
+function parseAppKey(apiBaseUrl) {
+  try {
+    const url = new URL(apiBaseUrl);
+    const match = url.hostname.match(/^([^.]+)\.[^.]+\.insforge\.app$/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
 var UsageTracker = class {
   apiBaseUrl;
   apiKey;
-  constructor(apiBaseUrl, apiKey) {
+  agentConnectedReported = false;
+  projectId;
+  accessToken;
+  isRemote;
+  constructor(apiBaseUrl, apiKey, options) {
     this.apiBaseUrl = apiBaseUrl;
     this.apiKey = apiKey;
+    this.projectId = options?.projectId;
+    this.accessToken = options?.accessToken;
+    this.isRemote = options?.isRemote ?? false;
   }
   async trackUsage(toolName, success = true) {
     if (!this.apiKey) {
       return;
     }
+    if (!this.agentConnectedReported) {
+      this.agentConnectedReported = true;
+      this.reportAgentConnected().catch((error) => {
+        console.error("Failed to report agent-connected:", error);
+      });
+    }
     try {
       const payload = {
         tool_name: toolName,
@@ -70,6 +93,27 @@ var UsageTracker = class {
       console.error("Failed to track usage:", error);
     }
   }
+  async reportAgentConnected() {
+    const body = {};
+    const headers = { "Content-Type": "application/json" };
+    if (this.isRemote && this.projectId && this.projectId !== "legacy") {
+      body.project_id = this.projectId;
+      if (this.accessToken) {
+        headers["Authorization"] = `Bearer ${this.accessToken}`;
+      }
+    } else {
+      const appKey = parseAppKey(this.apiBaseUrl);
+      if (!appKey) {
+        return;
+      }
+      body.app_key = appKey;
+    }
+    await fetch(`${PLATFORM_API_BASE}/tracking/v1/agent-connected`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+  }
 };
 
 // src/shared/tools/docs.ts
@@ -394,6 +438,12 @@ var storageBucketSchema = z5.object({
   public: z5.boolean(),
   createdAt: z5.string()
 });
+var storageConfigSchema = z5.object({
+  id: z5.string().uuid(),
+  maxFileSizeMb: z5.number().int().positive(),
+  createdAt: z5.string(),
+  updatedAt: z5.string()
+});
 
 // node_modules/@insforge/shared-schemas/dist/storage-api.schema.js
 import { z as z6 } from "zod";
@@ -440,6 +490,9 @@ var confirmUploadRequestSchema = z6.object({
   contentType: z6.string().optional(),
   etag: z6.string().optional()
 });
+var updateStorageConfigRequestSchema = z6.object({
+  maxFileSizeMb: z6.number().int().min(1, "Must be at least 1 MB").max(200, "Must be at most 200 MB")
+});
 
 // node_modules/@insforge/shared-schemas/dist/auth.schema.js
 import { z as z7 } from "zod";
@@ -497,6 +550,7 @@ var oAuthConfigSchema = z7.object({
   updatedAt: z7.string()
   // PostgreSQL timestamp
 });
+var allowedRedirectUrlsRegex = /^(?:(?:https?:\/\/)(?:(?:\*\.)?[^\s/:?#]+|\[[0-9A-Fa-f:.]+\])(?::\d+)?(?:\/[^\s]*)?|(?!(?:https?|javascript|data|file|vbscript):)[a-zA-Z][a-zA-Z0-9+.-]*:(?:\/\/[^\s/]+(?:\/[^\s]*)?|\/[^\s]*))$/i;
 var authConfigSchema = z7.object({
   id: z7.string().uuid(),
   requireEmailVerification: z7.boolean(),
@@ -507,7 +561,7 @@ var authConfigSchema = z7.object({
   requireSpecialChar: z7.boolean(),
   verifyEmailMethod: verificationMethodSchema,
   resetPasswordMethod: verificationMethodSchema,
-  signInRedirectTo: z7.union([z7.string().url(), z7.literal(""), z7.null()]).optional().transform((val) => val === "" ? null : val),
+  allowedRedirectUrls: z7.array(z7.string().regex(allowedRedirectUrlsRegex, { message: "Invalid URL or wildcard URL" })).optional().nullable(),
   createdAt: z7.string(),
   // PostgreSQL timestamp
   updatedAt: z7.string()
@@ -523,6 +577,16 @@ var tokenPayloadSchema = z7.object({
   exp: z7.number().optional()
   // Expiration
 });
+var customOAuthKeySchema = z7.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Key must contain only lowercase letters, numbers, hyphens, and underscores");
+var customOAuthConfigSchema = z7.object({
+  id: z7.string().uuid(),
+  key: customOAuthKeySchema,
+  name: z7.string().min(1),
+  discoveryEndpoint: z7.string().url(),
+  clientId: z7.string().min(1),
+  createdAt: z7.string(),
+  updatedAt: z7.string()
+});
 
 // node_modules/@insforge/shared-schemas/dist/auth-api.schema.js
 import { z as z8 } from "zod";
@@ -530,19 +594,19 @@ var paginationSchema = z8.object({
   limit: z8.string().optional(),
   offset: z8.string().optional()
 });
-var authOptionsSchema = z8.object({
-  emailRedirectTo: z8.string().url().optional()
-}).optional();
 var createUserRequestSchema = z8.object({
   email: emailSchema,
   password: passwordSchema,
   name: nameSchema.optional(),
-  options: authOptionsSchema
+  redirectTo: z8.string().url().optional()
 });
 var createSessionRequestSchema = z8.object({
   email: emailSchema,
   password: passwordSchema
 });
+var refreshSessionRequestSchema = z8.object({
+  refreshToken: z8.string().min(1, "refreshToken is required")
+});
 var exchangeAdminSessionRequestSchema = z8.object({
   code: z8.string()
 });
@@ -557,20 +621,19 @@ var updateProfileRequestSchema = z8.object({
 });
 var sendVerificationEmailRequestSchema = z8.object({
   email: emailSchema,
-  options: authOptionsSchema
+  redirectTo: z8.string().url().optional()
 });
 var verifyEmailRequestSchema = z8.object({
-  email: emailSchema.optional(),
-  otp: z8.string().min(1)
-}).refine((data) => data.email || data.otp, {
-  message: "Either email or otp must be provided"
+  email: emailSchema,
+  otp: z8.string().regex(/^\d{6}$/, "OTP code must be a 6-digit numeric code")
 });
 var sendResetPasswordEmailRequestSchema = z8.object({
-  email: emailSchema
+  email: emailSchema,
+  redirectTo: z8.string().url().optional()
 });
 var exchangeResetPasswordTokenRequestSchema = z8.object({
   email: emailSchema,
-  code: z8.string().min(1)
+  code: z8.string().regex(/^\d{6}$/, "Reset password code must be a 6-digit numeric code")
 });
 var resetPasswordRequestSchema = z8.object({
   newPassword: passwordSchema,
@@ -580,7 +643,6 @@ var createUserResponseSchema = z8.object({
   user: userSchema.optional(),
   accessToken: z8.string().nullable(),
   requireEmailVerification: z8.boolean().optional(),
-  redirectTo: z8.string().url().optional(),
   csrfToken: z8.string().nullable().optional(),
   refreshToken: z8.string().optional()
   // For mobile/desktop clients (no cookies)
@@ -588,7 +650,6 @@ var createUserResponseSchema = z8.object({
 var createSessionResponseSchema = z8.object({
   user: userSchema,
   accessToken: z8.string(),
-  redirectTo: z8.string().url().optional(),
   csrfToken: z8.string().nullable().optional(),
   refreshToken: z8.string().optional()
   // For mobile/desktop clients (no cookies)
@@ -596,7 +657,6 @@ var createSessionResponseSchema = z8.object({
 var verifyEmailResponseSchema = z8.object({
   user: userSchema,
   accessToken: z8.string(),
-  redirectTo: z8.string().url().optional(),
   csrfToken: z8.string().nullable().optional(),
   refreshToken: z8.string().optional()
   // For mobile/desktop clients (no cookies)
@@ -676,11 +736,12 @@ var updateAuthConfigRequestSchema = authConfigSchema.omit({
 }).partial();
 var getPublicAuthConfigResponseSchema = z8.object({
   oAuthProviders: z8.array(oAuthProvidersSchema),
+  customOAuthProviders: z8.array(customOAuthKeySchema),
   ...authConfigSchema.omit({
     id: true,
     updatedAt: true,
     createdAt: true,
-    signInRedirectTo: true
+    allowedRedirectUrls: true
   }).shape
 });
 var authErrorResponseSchema = z8.object({
@@ -689,6 +750,16 @@ var authErrorResponseSchema = z8.object({
   statusCode: z8.number().int(),
   nextActions: z8.string().optional()
 });
+var createCustomOAuthConfigRequestSchema = customOAuthConfigSchema.omit({ id: true, createdAt: true, updatedAt: true }).extend({
+  clientSecret: z8.string().min(1, "Client secret is required")
+});
+var updateCustomOAuthConfigRequestSchema = customOAuthConfigSchema.omit({ id: true, key: true, createdAt: true, updatedAt: true }).extend({
+  clientSecret: z8.string().min(1).optional()
+}).partial();
+var listCustomOAuthConfigsResponseSchema = z8.object({
+  data: z8.array(customOAuthConfigSchema),
+  count: z8.number()
+});
 
 // node_modules/@insforge/shared-schemas/dist/metadata.schema.js
 import { z as z11 } from "zod";
@@ -718,6 +789,9 @@ var realtimeMessageSchema = z9.object({
   whDeliveredCount: z9.number().int().min(0),
   createdAt: z9.string().datetime()
 });
+var realtimeConfigSchema = z9.object({
+  retentionDays: z9.number().int().positive().nullable()
+});
 var subscribeChannelPayloadSchema = z9.object({
   channel: z9.string().min(1)
   // The resolved channel instance, e.g., "order:123"
@@ -803,7 +877,8 @@ var messageStatsResponseSchema = z10.object({
   topEvents: z10.array(z10.object({
     eventName: z10.string(),
     count: z10.number().int().min(0)
-  }))
+  })),
+  retentionDays: realtimeConfigSchema.shape.retentionDays
 });
 var rlsPolicySchema = z10.object({
   policyName: z10.string(),
@@ -883,6 +958,9 @@ var databasePasswordInfoSchema = z11.object({
 var apiKeyResponseSchema = z11.object({
   apiKey: z11.string()
 });
+var projectIdResponseSchema = z11.object({
+  projectId: z11.string().nullable()
+});
 
 // node_modules/@insforge/shared-schemas/dist/ai.schema.js
 import { z as z12 } from "zod";
@@ -975,12 +1053,42 @@ var contentSchema = z13.union([
   audioContentSchema,
   fileContentSchema
 ]);
+var toolFunctionSchema = z13.object({
+  name: z13.string(),
+  description: z13.string().optional(),
+  parameters: z13.record(z13.unknown()).optional()
+});
+var toolSchema = z13.object({
+  type: z13.literal("function"),
+  function: toolFunctionSchema
+});
+var toolChoiceSchema = z13.union([
+  z13.enum(["auto", "none", "required"]),
+  z13.object({
+    type: z13.literal("function"),
+    function: z13.object({ name: z13.string() })
+  })
+]);
+var toolCallSchema = z13.object({
+  id: z13.string(),
+  type: z13.literal("function"),
+  function: z13.object({
+    name: z13.string(),
+    arguments: z13.string()
+  })
+});
 var chatMessageSchema = z13.object({
-  role: z13.enum(["user", "assistant", "system"]),
+  role: z13.enum(["user", "assistant", "system", "tool"]),
   // New format: content can be string or array of content parts (OpenAI-compatible)
-  content: z13.union([z13.string(), z13.array(contentSchema)]),
+  content: z13.union([z13.string(), z13.array(contentSchema)]).nullable(),
   // Legacy format: separate images field (deprecated but supported for backward compatibility)
-  images: z13.array(z13.object({ url: z13.string() })).optional()
+  images: z13.array(z13.object({ url: z13.string() })).optional(),
+  // Tool calls made by the assistant
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  tool_calls: z13.array(toolCallSchema).optional(),
+  // Tool call ID for tool response messages
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  tool_call_id: z13.string().optional()
 });
 var webSearchPluginSchema = z13.object({
   enabled: z13.boolean(),
@@ -1020,7 +1128,13 @@ var chatCompletionRequestSchema = z13.object({
   fileParser: fileParserPluginSchema.optional(),
   // Thinking/Reasoning mode: Enable extended reasoning capabilities
   // Appends ":thinking" to the model ID for chain-of-thought reasoning
-  thinking: z13.boolean().optional()
+  thinking: z13.boolean().optional(),
+  // Tool calling: Define functions the AI can call
+  tools: z13.array(toolSchema).optional(),
+  // Tool choice: Control whether/which tool is called ('auto', 'none', 'required', or specific function)
+  toolChoice: toolChoiceSchema.optional(),
+  // Parallel tool calls: Allow the model to call multiple tools in parallel
+  parallelToolCalls: z13.boolean().optional()
 });
 var urlCitationAnnotationSchema = z13.object({
   type: z13.literal("url_citation"),
@@ -1046,6 +1160,9 @@ var fileAnnotationSchema = z13.object({
 var annotationSchema = z13.union([urlCitationAnnotationSchema, fileAnnotationSchema]);
 var chatCompletionResponseSchema = z13.object({
   text: z13.string(),
+  // Tool calls from the assistant (present when the model invokes tools)
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  tool_calls: z13.array(toolCallSchema).optional(),
   // Annotations from web search or file parsing (can be URL citations or file annotations)
   annotations: z13.array(annotationSchema).optional(),
   metadata: z13.object({
@@ -1135,6 +1252,15 @@ var getAIUsageSummaryRequestSchema = z13.object({
   startDate: z13.string().datetime().optional(),
   endDate: z13.string().datetime().optional()
 });
+var keySourceSchema = z13.enum(["byok", "cloud", "env", "unconfigured"]);
+var gatewayConfigResponseSchema = z13.object({
+  keySource: keySourceSchema,
+  hasByokKey: z13.boolean(),
+  maskedKey: z13.string().optional()
+});
+var setGatewayBYOKKeyRequestSchema = z13.object({
+  apiKey: z13.string().min(1, "API key is required")
+});
 
 // node_modules/@insforge/shared-schemas/dist/logs.schema.js
 import { z as z14 } from "zod";
@@ -1165,6 +1291,16 @@ var logStatsSchema = z14.object({
   count: z14.number(),
   lastActivity: z14.string()
 });
+var buildLogEntrySchema = z14.object({
+  level: z14.string(),
+  message: z14.string()
+});
+var getBuildLogsResponseSchema = z14.object({
+  deploymentId: z14.string(),
+  status: z14.enum(["pending", "success", "failed"]),
+  logs: z14.array(buildLogEntrySchema),
+  createdAt: z14.string()
+});
 
 // node_modules/@insforge/shared-schemas/dist/logs-api.schema.js
 import { z as z15 } from "zod";
@@ -1240,7 +1376,19 @@ var listFunctionsResponseSchema = z17.object({
   functions: z17.array(functionSchema),
   runtime: z17.object({
     status: z17.enum(["running", "unavailable"])
-  })
+  }),
+  deploymentUrl: z17.string().nullable().optional()
+});
+var deploymentResultSchema = z17.object({
+  id: z17.string(),
+  status: z17.enum(["success", "failed"]),
+  url: z17.string().nullable(),
+  buildLogs: z17.array(z17.string()).optional()
+});
+var functionResponseSchema = z17.object({
+  success: z17.boolean(),
+  function: functionSchema,
+  deployment: deploymentResultSchema.nullable().optional()
 });
 
 // node_modules/@insforge/shared-schemas/dist/cloud-events.schema.js
@@ -1280,6 +1428,9 @@ var showContactModalEventSchema = z18.object({
 var showConnectOverlayEventSchema = z18.object({
   type: z18.literal("SHOW_CONNECT_OVERLAY")
 });
+var showPlanModalEventSchema = z18.object({
+  type: z18.literal("SHOW_PLAN_MODAL")
+});
 var authorizationCodeEventSchema = z18.object({
   type: z18.literal("AUTHORIZATION_CODE"),
   code: z18.string()
@@ -1288,6 +1439,51 @@ var routeChangeEventSchema = z18.object({
   type: z18.literal("ROUTE_CHANGE"),
   path: z18.string()
 });
+var requestProjectInfoEventSchema = z18.object({
+  type: z18.literal("REQUEST_PROJECT_INFO")
+});
+var projectInfoEventSchema = z18.object({
+  type: z18.literal("PROJECT_INFO"),
+  name: z18.string(),
+  instanceType: z18.string(),
+  region: z18.string(),
+  latestVersion: z18.string().optional()
+});
+var requestInstanceInfoEventSchema = z18.object({
+  type: z18.literal("REQUEST_INSTANCE_INFO")
+});
+var instanceInfoEventSchema = z18.object({
+  type: z18.literal("INSTANCE_INFO"),
+  currentInstanceType: z18.string(),
+  planName: z18.string(),
+  computeCredits: z18.number(),
+  currentOrgComputeCost: z18.number(),
+  instanceTypes: z18.array(z18.object({
+    id: z18.string(),
+    name: z18.string(),
+    cpu: z18.string(),
+    ram: z18.string(),
+    pricePerHour: z18.number(),
+    pricePerMonth: z18.number()
+  })),
+  projects: z18.array(z18.object({
+    name: z18.string(),
+    instanceType: z18.string(),
+    monthlyCost: z18.number(),
+    isCurrent: z18.boolean(),
+    status: z18.string()
+  }))
+});
+var requestInstanceTypeChangeEventSchema = z18.object({
+  type: z18.literal("REQUEST_INSTANCE_TYPE_CHANGE"),
+  instanceType: z18.string()
+});
+var instanceTypeChangeResultEventSchema = z18.object({
+  type: z18.literal("INSTANCE_TYPE_CHANGE_RESULT"),
+  success: z18.boolean(),
+  instanceType: z18.string().optional(),
+  error: z18.string().optional()
+});
 var cloudEventSchema = z18.discriminatedUnion("type", [
   appRouteChangeEventSchema,
   authSuccessEventSchema,
@@ -1299,8 +1495,15 @@ var cloudEventSchema = z18.discriminatedUnion("type", [
   navigateToUsageSchema,
   showContactModalEventSchema,
   showConnectOverlayEventSchema,
+  showPlanModalEventSchema,
   authorizationCodeEventSchema,
-  routeChangeEventSchema
+  routeChangeEventSchema,
+  requestProjectInfoEventSchema,
+  projectInfoEventSchema,
+  requestInstanceInfoEventSchema,
+  instanceInfoEventSchema,
+  requestInstanceTypeChangeEventSchema,
+  instanceTypeChangeResultEventSchema
 ]);
 
 // node_modules/@insforge/shared-schemas/dist/docs.schema.js
@@ -1336,8 +1539,6 @@ var docTypeSchema = z19.enum([
   "storage-sdk",
   "functions-sdk",
   "ai-integration-sdk",
-  "auth-components-react",
-  "auth-components-nextjs",
   "real-time",
   "deployment"
 ]).describe(`
@@ -1347,8 +1548,6 @@ var docTypeSchema = z19.enum([
       "storage-sdk" (file storage),
       "functions-sdk" (edge functions),
       "auth-sdk" (direct SDK methods for custom auth flows),
-      "auth-components-react" (authentication components for React+Vite applications),
-      "auth-components-nextjs" (authentication components for Next.js applications),
       "ai-integration-sdk" (AI features),
       "real-time" (real-time pub/sub through WebSockets),
       "deployment" (deploy frontend applications via MCP tool)
@@ -1433,6 +1632,96 @@ var listDeploymentsResponseSchema = z22.object({
     total: z22.number()
   })
 });
+var deploymentEnvVarSchema = z22.object({
+  id: z22.string(),
+  // Vercel env var ID (needed for delete/get)
+  key: z22.string(),
+  type: z22.enum(["plain", "encrypted", "secret", "sensitive", "system"]),
+  updatedAt: z22.number().optional()
+  // Unix timestamp (milliseconds)
+});
+var deploymentEnvVarWithValueSchema = z22.object({
+  id: z22.string(),
+  key: z22.string(),
+  value: z22.string(),
+  type: z22.enum(["plain", "encrypted", "secret", "sensitive", "system"]),
+  updatedAt: z22.number().optional()
+});
+var listEnvVarsResponseSchema = z22.object({
+  envVars: z22.array(deploymentEnvVarSchema)
+});
+var getEnvVarResponseSchema = z22.object({
+  envVar: deploymentEnvVarWithValueSchema
+});
+var upsertEnvVarRequestSchema = z22.object({
+  key: z22.string().trim().min(1, "key is required"),
+  value: z22.string()
+});
+var upsertEnvVarsRequestSchema = z22.object({
+  envVars: z22.array(upsertEnvVarRequestSchema).min(1)
+}).superRefine(({ envVars }, ctx) => {
+  const firstSeenByKey = /* @__PURE__ */ new Map();
+  envVars.forEach((envVar, index) => {
+    const existingIndex = firstSeenByKey.get(envVar.key);
+    if (existingIndex !== void 0) {
+      ctx.addIssue({
+        code: z22.ZodIssueCode.custom,
+        message: "duplicate environment variable key",
+        path: ["envVars", index, "key"]
+      });
+      return;
+    }
+    firstSeenByKey.set(envVar.key, index);
+  });
+});
+var upsertEnvVarResponseSchema = z22.object({
+  success: z22.literal(true),
+  message: z22.string()
+});
+var upsertEnvVarsResponseSchema = z22.object({
+  success: z22.literal(true),
+  message: z22.string(),
+  count: z22.number().int().positive()
+});
+var deleteEnvVarResponseSchema = z22.object({
+  success: z22.literal(true),
+  message: z22.string()
+});
+var updateSlugRequestSchema = z22.object({
+  slug: z22.string().trim().min(3, "slug must be at least 3 characters").max(63, "slug must be at most 63 characters").regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "slug must be lowercase alphanumeric with hyphens, not starting or ending with hyphen").nullable()
+});
+var updateSlugResponseSchema = z22.object({
+  success: z22.boolean(),
+  slug: z22.string().nullable(),
+  domain: z22.string().nullable()
+});
+var deploymentMetadataResponseSchema = z22.object({
+  currentDeploymentId: z22.string().uuid().nullable(),
+  defaultDomainUrl: z22.string().nullable(),
+  customDomainUrl: z22.string().nullable()
+});
+var domainVerificationRecordSchema = z22.object({
+  type: z22.string(),
+  domain: z22.string(),
+  value: z22.string()
+});
+var customDomainSchema = z22.object({
+  domain: z22.string(),
+  apexDomain: z22.string(),
+  verified: z22.boolean(),
+  misconfigured: z22.boolean(),
+  verification: z22.array(domainVerificationRecordSchema),
+  cnameTarget: z22.string().nullable(),
+  aRecordValue: z22.string().nullable()
+});
+var addCustomDomainRequestSchema = z22.object({
+  domain: z22.string().trim().min(1, "Domain is required").regex(/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i, "Invalid domain format (e.g. myapp.com or www.myapp.com)").refine((domain) => !domain.toLowerCase().endsWith(".insforge.site"), {
+    message: "Domains ending with .insforge.site are reserved by InsForge"
+  })
+});
+var listCustomDomainsResponseSchema = z22.object({
+  domains: z22.array(customDomainSchema)
+});
 
 // node_modules/@insforge/shared-schemas/dist/schedules.schema.js
 import { z as z23 } from "zod";
@@ -2628,7 +2917,11 @@ async function registerInsforgeTools(server, config = {}) {
   const GLOBAL_API_KEY = config.apiKey || process.env.API_KEY || "";
   const API_BASE_URL = config.apiBaseUrl || process.env.API_BASE_URL || "http://localhost:7130";
   const isRemote = config.mode === "remote";
-  const usageTracker = new UsageTracker(API_BASE_URL, GLOBAL_API_KEY);
+  const usageTracker = new UsageTracker(API_BASE_URL, GLOBAL_API_KEY, {
+    projectId: config.projectId,
+    accessToken: config.accessToken,
+    isRemote
+  });
   let backendVersion;
   try {
     backendVersion = await fetchBackendVersion(API_BASE_URL);

package/dist/http-server.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   registerInsforgeTools
-} from "./chunk-DZ5W3BSP.js";
+} from "./chunk-YH7HSQYJ.js";
 
 // src/http/server.ts
 import "dotenv/config";
@@ -98,7 +98,9 @@ var SessionManager = class {
     const toolsConfig = await registerInsforgeTools(server, {
       apiKey: sessionData.apiKey,
       apiBaseUrl: sessionData.apiBaseUrl,
-      mode: "remote"
+      mode: "remote",
+      projectId: sessionData.projectId,
+      accessToken: sessionData.oauthTokenHash
     });
     await server.connect(transport);
     const fullSessionData = {
@@ -186,7 +188,9 @@ var SessionManager = class {
     await registerInsforgeTools(server, {
       apiKey: sessionData.apiKey,
       apiBaseUrl: sessionData.apiBaseUrl,
-      mode: "remote"
+      mode: "remote",
+      projectId: sessionData.projectId,
+      accessToken: sessionData.oauthTokenHash
     });
     await server.connect(transport);
     this.runtimeSessions.set(sessionId, { server, transport, transportType: "streamable" });
@@ -210,7 +214,9 @@ var SessionManager = class {
     const toolsConfig = await registerInsforgeTools(server, {
       apiKey: sessionData.apiKey,
       apiBaseUrl: sessionData.apiBaseUrl,
-      mode: "remote"
+      mode: "remote",
+      projectId: sessionData.projectId,
+      accessToken: sessionData.oauthTokenHash
     });
     await server.connect(transport);
     const fullSessionData = {

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   registerInsforgeTools
-} from "./chunk-DZ5W3BSP.js";
+} from "./chunk-YH7HSQYJ.js";
 
 // src/stdio/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@insforge/mcp",
-  "version": "1.2.8",
+  "version": "1.2.9",
   "description": "MCP (Model Context Protocol) server for Insforge backend-as-a-service",
   "mcpName": "io.github.InsForge/insforge-mcp",
   "type": "module",
@@ -45,7 +45,7 @@
     "server.json"
   ],
   "dependencies": {
-    "@insforge/shared-schemas": "1.1.46",
+    "@insforge/shared-schemas": "1.1.47",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "archiver": "^7.0.1",
     "commander": "^14.0.0",