@blotout/qinto-cli 0.1.9 → 0.1.11

package/dist/worker-artifact/app-runtime/index.js

@@ -7,6 +7,10 @@ var __export = (target, all) => {
 // ../../../libs/app-manifest/src/cron.ts
 var MAX_CRON_LENGTH = 128;
 
+// ../../../libs/app-manifest/src/tool-names.ts
+var MAX_APP_TOOL_NAME_LENGTH = 32;
+var APP_TOOL_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+
 // ../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -2348,13 +2352,13 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
         canary.aborted = true;
         return canary;
       }
-      const checkResult = runChecks(payload, checks, ctx);
-      if (checkResult instanceof Promise) {
+      const checkResult2 = runChecks(payload, checks, ctx);
+      if (checkResult2 instanceof Promise) {
         if (ctx.async === false)
           throw new $ZodAsyncError();
-        return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
+        return checkResult2.then((checkResult3) => inst._zod.parse(checkResult3, ctx));
       }
-      return inst._zod.parse(checkResult, ctx);
+      return inst._zod.parse(checkResult2, ctx);
     };
     inst._zod.run = (payload, ctx) => {
       if (ctx.skipChecks) {
@@ -14628,6 +14632,11 @@ var envelopeResponseSchema = external_exports.object({
 var CONTROL_ENVELOPE_VERSION = 1;
 var MAX_CONTROL_BYTES = 256 * 1024;
 var MAX_MIGRATION_CHECKPOINT_BYTES = 16 * 1024;
+var MAX_TOOL_ARGUMENTS_BYTES = 32 * 1024;
+var MAX_TOOL_RESULT_BYTES = 64 * 1024;
+var MAX_TOOL_DATA_DEPTH = 8;
+var MAX_TOOL_DATA_NODES = 5e3;
+var MAX_TOOL_ERROR_MESSAGE_LENGTH = 512;
 var installSchema2 = external_exports.object({
   id: external_exports.string().min(1).max(64),
   ord: external_exports.number().int().min(1),
@@ -14697,19 +14706,39 @@ var scheduleSchema = external_exports.object({
       id: external_exports.string().min(1).max(64),
       ord: external_exports.number().int().min(1),
       label: external_exports.string().max(100),
-      catalogQueryTicket: external_exports.string().min(1).max(2048)
+      queryTicket: external_exports.string().min(1).max(2048)
     }).strict()
   ).min(1).max(MAX_INSTALLS_PER_APP)
 }).strict();
+var toolSchema = external_exports.object({
+  // The manifest's tools[].name, never the `<slug>_` composed MCP name: the slug is already in
+  // `app.slug`, and carrying it twice would give the app worker two sources for one fact.
+  name: external_exports.string().min(1).max(MAX_APP_TOOL_NAME_LENGTH).regex(APP_TOOL_NAME_PATTERN),
+  // Who asked, and what they may do on this site. Derived from the bearer by the portal, never
+  // from the model's arguments.
+  viewer: external_exports.object({ userId: external_exports.string().min(1).max(64), access: external_exports.enum(["read", "write"]) }).strict(),
+  // Already validated against the tool's declared inputSchema, with the reserved routing names
+  // stripped. Every declared input schema has an object root, so this is an object too — and a
+  // call that names no arguments normalizes to `{}` rather than reaching the handler as undefined.
+  arguments: external_exports.record(external_exports.string(), external_exports.unknown()).default({}),
+  // Stable across a collapsed retry, so an app can deduplicate its external effects on it.
+  callId: external_exports.string().min(1).max(64),
+  // The short-lived install/version-scoped credential used only by the app runtime's query
+  // broker. It never enters handler arguments or app-authored result data.
+  queryTicket: external_exports.string().min(1).max(2048)
+}).strict().refine((tool) => {
+  return new TextEncoder().encode(JSON.stringify(tool.arguments)).length <= MAX_TOOL_ARGUMENTS_BYTES;
+}, "Tool arguments exceed the size cap");
 var controlEnvelopeSchema = external_exports.object({
   v: external_exports.literal(CONTROL_ENVELOPE_VERSION),
-  kind: external_exports.enum(["noop", "lifecycle", "migration", "schedule"]),
+  kind: external_exports.enum(["noop", "lifecycle", "migration", "schedule", "tool"]),
   site: external_exports.object({ origin: external_exports.string().min(1).max(255) }).strict(),
   app: external_exports.object({ slug: external_exports.string().min(1).max(30), version: external_exports.string().min(1).max(32) }).strict(),
   install: external_exports.object({ id: external_exports.string().min(1).max(64), ord: external_exports.number().int().min(1), label: external_exports.string().max(100) }).strict().optional(),
   lifecycle: lifecycleEventSchema.optional(),
   migration: migrationSchema.optional(),
-  schedule: scheduleSchema.optional()
+  schedule: scheduleSchema.optional(),
+  tool: toolSchema.optional()
 }).strict().superRefine((envelope, ctx) => {
   if (envelope.kind === "lifecycle" !== (envelope.lifecycle !== void 0)) {
     ctx.addIssue({ code: "custom", path: ["lifecycle"], message: "Lifecycle payload must match the control kind" });
@@ -14720,13 +14749,50 @@ var controlEnvelopeSchema = external_exports.object({
   if (envelope.kind === "schedule" !== (envelope.schedule !== void 0)) {
     ctx.addIssue({ code: "custom", path: ["schedule"], message: "Schedule payload must match the control kind" });
   }
+  if (envelope.kind === "tool" !== (envelope.tool !== void 0)) {
+    ctx.addIssue({ code: "custom", path: ["tool"], message: "Tool payload must match the control kind" });
+  }
   if (envelope.kind === "lifecycle" && envelope.install === void 0) {
     ctx.addIssue({ code: "custom", path: ["install"], message: "Lifecycle control needs an install" });
   }
+  if (envelope.kind === "tool" && envelope.install === void 0) {
+    ctx.addIssue({ code: "custom", path: ["install"], message: "Tool control needs an install" });
+  }
 });
+var toolDataWithinLimits = (value) => {
+  const stack = [{ value, depth: 0 }];
+  let seen = 0;
+  while (stack.length > 0) {
+    const next = stack.pop();
+    seen += 1;
+    if (next.depth > MAX_TOOL_DATA_DEPTH || seen > MAX_TOOL_DATA_NODES) {
+      return false;
+    }
+    if (next.value !== null && typeof next.value === "object") {
+      for (const child of Object.values(next.value)) {
+        stack.push({ value: child, depth: next.depth + 1 });
+      }
+    }
+  }
+  return true;
+};
+var toolResultSchema = external_exports.object({
+  content: external_exports.string().max(MAX_TOOL_RESULT_BYTES),
+  // MCP defines `structuredContent` as an object, so a bare scalar or array is refused here rather
+  // than surfacing as a protocol error at the client.
+  data: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+  // True when the handler chose to fail with `ctx.fail`: `content` is then the app's own message
+  // for the model. A thrown handler is `ok: false` with no `tool` at all.
+  failed: external_exports.boolean()
+}).strict().refine((result) => {
+  return toolDataWithinLimits(result.data);
+}, "Tool result nests too deeply or carries too many values").refine((result) => {
+  return new TextEncoder().encode(JSON.stringify({ content: result.content, data: result.data ?? null })).length <= MAX_TOOL_RESULT_BYTES;
+}, "Tool result exceeds the size cap");
 var controlResponseSchema = external_exports.object({
   v: external_exports.literal(CONTROL_ENVELOPE_VERSION),
   ok: external_exports.boolean(),
+  tool: toolResultSchema.optional(),
   migration: external_exports.union([
     external_exports.object({ done: external_exports.literal(true) }).strict(),
     external_exports.object({ done: external_exports.literal(false), checkpoint: external_exports.unknown() }).strict().refine((result) => {
@@ -14869,6 +14935,9 @@ var appUiWritePath = (domainId, appSlug2) => {
 var appUiCatalogQueryPath = (domainId, appSlug2, resourceIdentifier) => {
   return `/app-ui/sites/${domainId}/apps/${appSlug2}/catalogs/${resourceIdentifier}/query`;
 };
+var appUiAnalyticsQueryPath = (domainId, appSlug2, resourceIdentifier) => {
+  return `/app-ui/sites/${domainId}/apps/${appSlug2}/analytics/${resourceIdentifier}/query`;
+};
 var uiInstallSchema = external_exports.object({ id: external_exports.string().min(1).max(64), ord: external_exports.number().int().min(1), label: external_exports.string().max(100), enabled: external_exports.boolean() }).strict();
 var uiContextSchema = external_exports.object({
   version: external_exports.string().min(1).max(32),
@@ -16132,43 +16201,58 @@ var failureMessage = (error51) => {
   return message.slice(0, MAX_ERROR_MESSAGE_LENGTH);
 };
 
-// src/catalog-query.ts
-var MAX_CATALOG_RESPONSE_BYTES = 5 * 1024 * 1024;
-var parseCatalogResponse = async (response) => {
-  const raw = await readBody(response, MAX_CATALOG_RESPONSE_BYTES);
+// src/query.ts
+var MAX_QUERY_RESPONSE_BYTES = 5 * 1024 * 1024;
+var parseQueryResponse = async (kind, response) => {
+  const raw = await readBody(response, MAX_QUERY_RESPONSE_BYTES);
   if (raw === null) {
-    throw new Error("The catalog query response exceeded the app runtime limit.");
+    throw new Error(`The ${kind} query response exceeded the app runtime limit.`);
   }
   let body;
   try {
     body = JSON.parse(raw);
   } catch {
-    throw new Error(`The catalog query returned an invalid response (${response.status}).`);
+    throw new Error(`The ${kind} query returned an invalid response (${response.status}).`);
   }
   if (!response.ok) {
     const error51 = body;
     const reason = typeof error51.message === "string" ? error51.message : typeof error51.error === "string" ? error51.error : `request failed with status ${response.status}`;
-    throw new Error(`Catalog query failed: ${reason}`);
+    throw new Error(`${kind === "catalog" ? "Catalog" : "Analytics"} query failed: ${reason}`);
   }
   return body;
 };
-var buildCatalogQuery = ({ env, ticket, installId }) => {
+var buildQuery = ({ env, ticket, installId }) => {
+  const platform = env;
+  const context = JSON.parse(platform.APP_CONTEXT);
+  const post = async (kind, path, resourceIdentifier, sql) => {
+    return traced(
+      `qinto.${kind}.query`,
+      { attrs: { "app.install_id": installId, [`app.${kind}.resource`]: resourceIdentifier } },
+      async () => {
+        const response = await fetch(new URL(path, platform.QINTO_PLATFORM_API), {
+          method: "POST",
+          headers: { authorization: `Bearer ${ticket}`, "content-type": "application/json" },
+          body: JSON.stringify({ sql })
+        });
+        return parseQueryResponse(kind, response);
+      }
+    );
+  };
   return {
     catalog: async (resourceIdentifier, sql) => {
-      const platform = env;
-      const context = JSON.parse(platform.APP_CONTEXT);
-      const path = appUiCatalogQueryPath(context.domainId, context.slug, resourceIdentifier);
-      return traced(
-        "qinto.catalog.query",
-        { attrs: { "app.install_id": installId, "app.catalog.resource": resourceIdentifier } },
-        async () => {
-          const response = await fetch(new URL(path, platform.QINTO_PLATFORM_API), {
-            method: "POST",
-            headers: { authorization: `Bearer ${ticket}`, "content-type": "application/json" },
-            body: JSON.stringify({ sql })
-          });
-          return parseCatalogResponse(response);
-        }
+      return post(
+        "catalog",
+        appUiCatalogQueryPath(context.domainId, context.slug, resourceIdentifier),
+        resourceIdentifier,
+        sql
+      );
+    },
+    analytics: async (resourceIdentifier, sql) => {
+      return post(
+        "analytics",
+        appUiAnalyticsQueryPath(context.domainId, context.slug, resourceIdentifier),
+        resourceIdentifier,
+        sql
       );
     }
   };
@@ -16177,7 +16261,8 @@ var buildCatalogQuery = ({ env, ticket, installId }) => {
 // src/schedule.ts
 var dispatchSchedule = async (envelope, bundle, env) => {
   const schedule = envelope.schedule;
-  const handler = bundle.schedules?.[schedule.id];
+  const schedules = bundle.schedules;
+  const handler = schedules !== void 0 && Object.hasOwn(schedules, schedule.id) ? schedules[schedule.id] : void 0;
   if (typeof handler !== "function") {
     return json2(200, {
       v: CONTROL_ENVELOPE_VERSION,
@@ -16209,7 +16294,7 @@ var dispatchSchedule = async (envelope, bundle, env) => {
       appSecrets: appScope.appSecrets,
       observability: buildObservability(install.ord),
       apps: buildAppsClient(env, { depth: 0 }),
-      query: buildCatalogQuery({ env, ticket: install.catalogQueryTicket, installId: install.id }),
+      query: buildQuery({ env, ticket: install.queryTicket, installId: install.id }),
       push: async (userId, message) => {
         await brokerPush(env, {
           userId,
@@ -16239,6 +16324,142 @@ var dispatchSchedule = async (envelope, bundle, env) => {
   return json2(200, { v: CONTROL_ENVELOPE_VERSION, ok: true });
 };
 
+// src/tool.ts
+var failure = (message) => {
+  return json2(200, { v: CONTROL_ENVELOPE_VERSION, ok: false, error: { message } });
+};
+var isFailure = (value) => {
+  return value !== null && typeof value === "object" && value.kind === "tool_error" && typeof value.message === "string";
+};
+var isResult = (value) => {
+  return value !== null && typeof value === "object" && typeof value.content === "string";
+};
+var isStructuredData = (data) => {
+  return data === void 0 || data !== null && typeof data === "object" && !Array.isArray(data);
+};
+var isPlainContainer = (value) => {
+  const prototype = Object.getPrototypeOf(value);
+  return Array.isArray(value) || prototype === Object.prototype || prototype === null;
+};
+var jsonScalarVerdict = (value) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return "ok";
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? "ok" : "invalid";
+  }
+  if (value === void 0 || typeof value !== "object" || !isPlainContainer(value)) {
+    return "invalid";
+  }
+  return "container";
+};
+var isJsonValue = (root) => {
+  const stack = [root];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const value = stack.pop();
+    const verdict = jsonScalarVerdict(value);
+    if (verdict === "invalid") {
+      return false;
+    }
+    if (verdict === "ok" || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    if (Array.isArray(value) && Object.keys(value).length !== value.length) {
+      return false;
+    }
+    stack.push(...Object.values(value));
+  }
+  return true;
+};
+var truncate = (message) => {
+  return message.length <= MAX_TOOL_ERROR_MESSAGE_LENGTH ? message : message.slice(0, MAX_TOOL_ERROR_MESSAGE_LENGTH);
+};
+var checkResult = (result) => {
+  if (!isStructuredData(result.data)) {
+    return "not_structured";
+  }
+  if (result.data !== void 0 && !isJsonValue(result.data)) {
+    return "not_serializable";
+  }
+  let encoded;
+  try {
+    encoded = new TextEncoder().encode(JSON.stringify({ content: result.content, data: result.data ?? null }));
+  } catch {
+    return "not_serializable";
+  }
+  if (encoded.length > MAX_TOOL_RESULT_BYTES || !toolDataWithinLimits(result.data)) {
+    return "too_large";
+  }
+  return "ok";
+};
+var buildContext2 = (envelope, env) => {
+  const install = envelope.install;
+  const { variableKinds, appVariableKinds } = contextKindsOf(env);
+  const maps = parseVariableMaps(env);
+  const appScope = projectAppValues(env, appVariableKinds);
+  const { variables, secrets } = projectInstallValues(maps, variableKinds, install.ord);
+  return {
+    env,
+    site: envelope.site,
+    install: { id: install.id, label: install.label },
+    viewer: envelope.tool.viewer,
+    callId: envelope.tool.callId,
+    startWorkflow: buildStartWorkflow({ ord: install.ord, installId: install.id, installLabel: install.label, anonId: null }),
+    oauth: buildOauth(env, install.ord),
+    variables,
+    secrets,
+    appVariables: appScope.appVariables,
+    appSecrets: appScope.appSecrets,
+    observability: buildObservability(install.ord),
+    apps: buildAppsClient(env, { depth: 0 }),
+    query: buildQuery({ env, ticket: envelope.tool.queryTicket, installId: install.id }),
+    fail: (message) => {
+      return { kind: "tool_error", message: truncate(message) };
+    }
+  };
+};
+var dispatchTool = async (envelope, bundle, env) => {
+  const name = envelope.tool.name;
+  const tools = bundle.tools;
+  const handler = tools !== void 0 && Object.hasOwn(tools, name) ? tools[name] : void 0;
+  if (typeof handler !== "function") {
+    return failure(`missing handler: tools.${name}`);
+  }
+  setSpanAttributes({ "app.tool": name, "app.tool_call_id": envelope.tool.callId });
+  let value;
+  try {
+    value = await installSpan(envelope.install, () => {
+      return handler(envelope.tool.arguments, buildContext2(envelope, env));
+    });
+  } catch (error51) {
+    console.warn(`tool ${name} failed for install ${envelope.install.id}: ${failureMessage(error51)}`);
+    return failure(`tool ${name} failed`);
+  }
+  if (isFailure(value)) {
+    return json2(200, { v: CONTROL_ENVELOPE_VERSION, ok: true, tool: { content: truncate(value.message), failed: true } });
+  }
+  if (!isResult(value)) {
+    return failure(`tool ${name} returned no result`);
+  }
+  const verdict = checkResult(value);
+  if (verdict === "not_structured") {
+    return failure(`tool ${name} returned data that is not a JSON object`);
+  }
+  if (verdict === "not_serializable") {
+    return failure(`tool ${name} returned data that cannot be serialized`);
+  }
+  if (verdict === "too_large") {
+    return failure(`tool ${name} returned a result over the size cap`);
+  }
+  return json2(200, {
+    v: CONTROL_ENVELOPE_VERSION,
+    ok: true,
+    tool: { content: value.content, ...value.data === void 0 ? {} : { data: value.data }, failed: false }
+  });
+};
+
 // src/control.ts
 var controlError = (status, message) => {
   return json2(status, { v: CONTROL_ENVELOPE_VERSION, ok: false, error: { message } });
@@ -16378,6 +16599,9 @@ var dispatchControl = async ({ request, env, versions }) => {
     case "schedule": {
       return dispatchSchedule(envelope, bundle, env);
     }
+    case "tool": {
+      return dispatchTool(envelope, bundle, env);
+    }
   }
 };
 
@@ -16410,7 +16634,7 @@ var handlerRequest = (request, context, body) => {
     body: body.byteLength === 0 ? void 0 : body
   });
 };
-var buildContext2 = ({ env, maps, kinds, appScope, install, site, params }) => {
+var buildContext3 = ({ env, maps, kinds, appScope, install, site, params }) => {
   const { variables, secrets } = projectInstallValues(maps, kinds, install.ord);
   return {
     env,
@@ -16502,7 +16726,7 @@ var dispatchEndpoint = async ({ request, env, versions }) => {
     return installSpan(install, () => {
       return handler(
         handlerRequest(request, context, body),
-        buildContext2({ env, maps, kinds: variableKinds, appScope, install, site: context.site, params: context.params })
+        buildContext3({ env, maps, kinds: variableKinds, appScope, install, site: context.site, params: context.params })
       );
     });
   };
@@ -16788,7 +17012,7 @@ var runInstalls = async (envelope, env, invoke) => {
   const { variableKinds: kinds, appVariableKinds } = contextKindsOf(env);
   const appScope = projectAppValues(env, appVariableKinds);
   const groups = [];
-  let failure;
+  let failure2;
   for (const install of envelope.installs) {
     const emits = [];
     const pushes = [];
@@ -16802,7 +17026,7 @@ var runInstalls = async (envelope, env, invoke) => {
     } catch (error51) {
       const message = failureMessage(error51);
       console.warn(`app hook failed for install ${install.id}: ${message}`);
-      failure ??= message;
+      failure2 ??= message;
       continue;
     }
     const contextWrites = context.writes();
@@ -16814,8 +17038,8 @@ var runInstalls = async (envelope, env, invoke) => {
   if (groups.length > 0) {
     body.effects = groups;
   }
-  if (failure !== void 0) {
-    body.error = { message: failure };
+  if (failure2 !== void 0) {
+    body.error = { message: failure2 };
   }
   return json2(200, body);
 };