robotrock 1.3.3 → 1.4.0

package/dist/eve/agent/index.js

@@ -118,6 +118,158 @@ function verifyRobotRockPlatformUserContextJwt(args) {
 // ../core/src/eve/platform-user-context-public-key.ts
 var ROBOTROCK_PLATFORM_USER_CONTEXT_PUBLIC_KEY_URL = "https://app.robotrock.io/.well-known/robotrock-user-context-public-key";
 
+// ../core/src/utils/decode-html-entities.ts
+function decodeHtmlEntities(value) {
+  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#039;/g, "'").replace(/&apos;/g, "'").replace(/&#(\d+);/g, (_, code) => String.fromCharCode(Number(code))).replace(
+    /&#x([0-9a-f]+);/gi,
+    (_, code) => String.fromCharCode(parseInt(code, 16))
+  );
+}
+
+// ../core/src/utils/safe-url.ts
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+  "localhost",
+  "metadata.google.internal",
+  "metadata.goog"
+]);
+function normalizeHostname(hostname) {
+  return hostname.toLowerCase().replace(/^\[|\]$/g, "");
+}
+function isBlockedIpv4(host) {
+  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (!match) {
+    return false;
+  }
+  const octets = match.slice(1, 5).map((part) => Number(part));
+  if (octets.some((octet) => Number.isNaN(octet) || octet < 0 || octet > 255)) {
+    return true;
+  }
+  const [a, b, _c, _d] = octets;
+  if (a === void 0 || b === void 0) {
+    return true;
+  }
+  if (a === 127 || a === 0) return true;
+  if (a === 10) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  return false;
+}
+function ipv4FromNumericHost(host) {
+  if (/^\d+$/.test(host)) {
+    const num = Number(host);
+    if (!Number.isFinite(num) || num < 0 || num > 4294967295) {
+      return null;
+    }
+    const a = num >>> 24 & 255;
+    const b = num >>> 16 & 255;
+    const c = num >>> 8 & 255;
+    const d = num & 255;
+    return `${a}.${b}.${c}.${d}`;
+  }
+  const hexMatch = /^0x([0-9a-f]{1,8})$/i.exec(host);
+  if (hexMatch) {
+    const num = Number.parseInt(hexMatch[1], 16);
+    if (!Number.isFinite(num) || num < 0 || num > 4294967295) {
+      return null;
+    }
+    const a = num >>> 24 & 255;
+    const b = num >>> 16 & 255;
+    const c = num >>> 8 & 255;
+    const d = num & 255;
+    return `${a}.${b}.${c}.${d}`;
+  }
+  return null;
+}
+function isBlockedIpv4Mapped(host) {
+  const mappedDotted = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/i.exec(host);
+  if (mappedDotted) {
+    return isBlockedIpv4(mappedDotted[1]);
+  }
+  const mappedHex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i.exec(host);
+  if (mappedHex) {
+    const high = Number.parseInt(mappedHex[1], 16);
+    const low = Number.parseInt(mappedHex[2], 16);
+    if (Number.isFinite(high) && Number.isFinite(low)) {
+      const a = high >> 8 & 255;
+      const b = high & 255;
+      const c = low >> 8 & 255;
+      const d = low & 255;
+      return isBlockedIpv4(`${a}.${b}.${c}.${d}`);
+    }
+  }
+  return false;
+}
+function isBlockedIpv6(host) {
+  if (host === "::1" || host === "0:0:0:0:0:0:0:1") {
+    return true;
+  }
+  if (host.startsWith("fc") || host.startsWith("fd")) {
+    return true;
+  }
+  if (host.startsWith("fe80:")) {
+    return true;
+  }
+  if (isBlockedIpv4Mapped(host)) {
+    return true;
+  }
+  return false;
+}
+function isBlockedHostname(hostname) {
+  const host = normalizeHostname(hostname);
+  if (!host) {
+    return true;
+  }
+  if (BLOCKED_HOSTNAMES.has(host)) {
+    return true;
+  }
+  if (host.endsWith(".localhost") || host.endsWith(".local")) {
+    return true;
+  }
+  const numericIpv4 = ipv4FromNumericHost(host);
+  if (numericIpv4 && isBlockedIpv4(numericIpv4)) {
+    return true;
+  }
+  return isBlockedIpv4(host) || isBlockedIpv6(host);
+}
+function isLoopbackHandlerUrl(urlString) {
+  let url;
+  try {
+    url = new URL(urlString);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return false;
+  }
+  if (url.username || url.password) {
+    return false;
+  }
+  const host = url.hostname.toLowerCase();
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]" || host.endsWith(".localhost");
+}
+function isAllowedHandlerUrl(urlString) {
+  return isPublicHttpUrl(urlString) || isLoopbackHandlerUrl(urlString);
+}
+function isPublicHttpUrl(urlString) {
+  let url;
+  try {
+    url = new URL(urlString);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return false;
+  }
+  if (url.username || url.password) {
+    return false;
+  }
+  return !isBlockedHostname(url.hostname);
+}
+var PUBLIC_HTTP_URL_ERROR = "URL must be a public http:// or https:// address";
+var HANDLER_URL_ERROR = "Handler URL must be a public or loopback http:// or https:// address";
+
 // src/eve/input-request.ts
 var EVE_INPUT_SUBMIT_ACTION_ID = "submit";
 var EVE_INPUT_OTHER_CHOICE_ID = "__other__";
@@ -127,6 +279,9 @@ var CONFIRMATION_DEFAULT_OPTIONS = [
   { id: "deny", label: "Deny", style: "danger" }
 ];
 var SELECT_PER_OPTION_THRESHOLD = 6;
+function decodeDisplayText(value) {
+  return decodeHtmlEntities(value);
+}
 function resolveEveInputDisplay(request, toolName) {
   if (request.display) {
     return request.display;
@@ -143,11 +298,12 @@ function confirmationActions(request) {
   const options = request.options && request.options.length > 0 ? request.options : CONFIRMATION_DEFAULT_OPTIONS;
   return options.map((option) => ({
     id: option.id,
-    title: option.label,
-    ...option.description ? { description: option.description } : {}
+    title: decodeDisplayText(option.label),
+    ...option.description ? { description: decodeDisplayText(option.description) } : {}
   }));
 }
 function textSubmitAction(prompt) {
+  const decodedPrompt = decodeDisplayText(prompt);
   return {
     id: EVE_INPUT_SUBMIT_ACTION_ID,
     title: "Submit",
@@ -163,7 +319,7 @@ function textSubmitAction(prompt) {
     },
     ui: {
       answer: {
-        "ui:title": prompt.trim() || "Your answer",
+        "ui:title": decodedPrompt.trim() || "Your answer",
         "ui:widget": "textarea"
       }
     }
@@ -172,15 +328,15 @@ function textSubmitAction(prompt) {
 function selectPerOptionActions(options) {
   return options.map((option) => ({
     id: option.id,
-    title: option.label,
-    ...option.description ? { description: option.description } : {}
+    title: decodeDisplayText(option.label),
+    ...option.description ? { description: decodeDisplayText(option.description) } : {}
   }));
 }
 function selectFormAction(request) {
   const options = request.options ?? [];
   const allowFreeform = request.allowFreeform === true;
   const enumValues = options.map((option) => option.id);
-  const enumNames = options.map((option) => option.label);
+  const enumNames = options.map((option) => decodeDisplayText(option.label));
   if (allowFreeform) {
     enumValues.push(EVE_INPUT_OTHER_CHOICE_ID);
     enumNames.push(EVE_INPUT_OTHER_CHOICE_LABEL);
@@ -303,6 +459,12 @@ function isEveApprovalInputRequest(request) {
   const options = request.options ?? [];
   return options.length === 2 && options[0]?.id === "approve" && options[1]?.id === "deny";
 }
+function buildOptionIdFormData(display, optionId) {
+  if (display === "select" || display === "confirmation") {
+    return { choice: optionId };
+  }
+  return {};
+}
 function eveInputResponseToActionSubmission(request, response, options) {
   const display = resolveEveInputDisplay(request, options?.toolName);
   const actions = eveInputRequestToActions(request, options);
@@ -312,7 +474,7 @@ function eveInputResponseToActionSubmission(request, response, options) {
       return {
         actionId: response.optionId,
         actionTitle: action.title,
-        formData: {}
+        formData: buildOptionIdFormData(display, response.optionId)
       };
     }
     const option = request.options?.find((entry) => entry.id === response.optionId);
@@ -320,13 +482,13 @@ function eveInputResponseToActionSubmission(request, response, options) {
       return {
         actionId: response.optionId,
         actionTitle: option.label,
-        formData: {}
+        formData: buildOptionIdFormData(display, response.optionId)
       };
     }
     return {
       actionId: response.optionId,
       actionTitle: response.optionId,
-      formData: {}
+      formData: buildOptionIdFormData(display, response.optionId)
     };
   }
   const text = response.text?.trim();
@@ -389,6 +551,190 @@ function parseEveAskQuestionToolOutput(output) {
   return { ...optionId ? { optionId } : {}, ...text ? { text } : {} };
 }
 
+// src/eve/tool-result-ui-meta.ts
+var TOOL_RESULT_UI_ENTITY_ID_RE = /^[a-z][a-z0-9_]{0,63}$/;
+
+// src/eve/entity-schemas.ts
+import { z } from "zod";
+var toolResultUiMetaSchema = z.object({
+  present: z.boolean().optional(),
+  entity: z.string().regex(TOOL_RESULT_UI_ENTITY_ID_RE).optional(),
+  rowsPath: z.string().min(1).optional(),
+  layout: z.enum(["list", "chart", "table"]).optional()
+}).strict();
+var agentOnlyFields = {
+  replyGuidance: z.string().optional(),
+  ui: toolResultUiMetaSchema.optional(),
+  uiHint: z.enum(["list", "chart", "table"]).optional()
+};
+function withAgentOnlyFields(shape) {
+  return z.object({
+    ...shape,
+    ...agentOnlyFields
+  });
+}
+var productEntityRowSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  price: z.number(),
+  currency: z.string().min(1),
+  inStock: z.boolean(),
+  url: z.string().min(1)
+});
+var metricPointEntityRowSchema = z.object({
+  date: z.string().optional(),
+  category: z.string().optional(),
+  label: z.string().optional()
+}).catchall(z.union([z.string(), z.number()]));
+var memberEntityRowSchema = z.object({
+  name: z.string(),
+  email: z.string(),
+  role: z.string(),
+  membershipKind: z.string(),
+  profilePictureUrl: z.string().nullable()
+});
+var taskEntityRowSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  status: z.string().min(1),
+  type: z.string().nullable(),
+  description: z.string().nullable(),
+  validUntil: z.number(),
+  createdAt: z.number(),
+  url: z.string().min(1),
+  threadPriority: z.string().nullable().optional()
+});
+var groupEntityRowSchema = z.object({
+  name: z.string().min(1),
+  slug: z.string().min(1),
+  description: z.string().nullable(),
+  memberCount: z.number().nullable(),
+  url: z.string().min(1)
+});
+var groupDetailEntitySchema = z.object({
+  name: z.string().min(1),
+  slug: z.string().min(1),
+  description: z.string().nullable(),
+  url: z.string().min(1),
+  members: z.array(
+    z.object({
+      name: z.string(),
+      email: z.string(),
+      profilePictureUrl: z.string().nullable()
+    })
+  )
+});
+var statusEntityRowSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  status: z.string().min(1),
+  url: z.string().min(1),
+  type: z.string().nullable().optional(),
+  description: z.string().nullable().optional()
+});
+var agentAdminErrorResultSchema = z.object({
+  ok: z.literal(false),
+  status: z.number().optional(),
+  message: z.string(),
+  response: z.unknown().optional()
+});
+var agentAdminMutationResultSchema = z.object({
+  ...agentOnlyFields
+}).passthrough();
+var searchProductsOutputSchema = withAgentOnlyFields({
+  items: z.array(productEntityRowSchema)
+});
+var generateRandomChartOutputSchema = withAgentOnlyFields({
+  title: z.string().min(1),
+  axis: z.enum(["time", "category"]),
+  series: z.array(metricPointEntityRowSchema)
+});
+var generateImageOutputSchema = withAgentOnlyFields({
+  prompt: z.string().min(1),
+  mediaType: z.string().min(1),
+  model: z.string().min(1),
+  storageId: z.string().min(1),
+  url: z.string().min(1),
+  /** @deprecated Legacy sessions only — prefer storageId/url. */
+  base64: z.string().min(1).optional()
+});
+var manageTeamMembersListOutputSchema = withAgentOnlyFields({
+  members: z.array(memberEntityRowSchema)
+});
+var manageTeamMembersDetailOutputSchema = withAgentOnlyFields(
+  memberEntityRowSchema.shape
+);
+var manageTeamMembersOutputSchema = z.union([
+  manageTeamMembersListOutputSchema,
+  manageTeamMembersDetailOutputSchema,
+  agentAdminMutationResultSchema,
+  agentAdminErrorResultSchema
+]);
+var manageGroupsListOutputSchema = withAgentOnlyFields({
+  groups: z.array(groupEntityRowSchema)
+});
+var manageGroupsDetailOutputSchema = withAgentOnlyFields(
+  groupDetailEntitySchema.shape
+);
+var manageGroupsSummaryOutputSchema = withAgentOnlyFields(
+  groupEntityRowSchema.shape
+);
+var manageGroupsOutputSchema = z.union([
+  manageGroupsListOutputSchema,
+  manageGroupsDetailOutputSchema,
+  manageGroupsSummaryOutputSchema,
+  agentAdminMutationResultSchema,
+  agentAdminErrorResultSchema
+]);
+var queryTasksListOutputSchema = withAgentOnlyFields({
+  items: z.array(taskEntityRowSchema),
+  nextCursor: z.string().nullable().optional()
+});
+var queryTasksDetailOutputSchema = withAgentOnlyFields({
+  id: z.string().nullable(),
+  status: z.string().nullable(),
+  type: z.string().nullable(),
+  name: z.string().nullable(),
+  description: z.string().nullable(),
+  validUntil: z.number().nullable(),
+  createdAt: z.number().nullable(),
+  url: z.string().min(1).nullable()
+});
+var queryTasksOutputSchema = z.union([
+  queryTasksListOutputSchema,
+  queryTasksDetailOutputSchema,
+  agentAdminErrorResultSchema
+]);
+var assignTasksOutputSchema = z.union([
+  withAgentOnlyFields({
+    results: z.array(statusEntityRowSchema)
+  }),
+  agentAdminErrorResultSchema
+]);
+var workspaceUsageEntitySchema = z.object({
+  workspace: z.string(),
+  plan: z.string(),
+  planType: z.string(),
+  trialState: z.string(),
+  daysRemaining: z.number().nullable(),
+  isPaidPro: z.boolean(),
+  subscriptionStatus: z.string(),
+  tasksToday: z.string(),
+  tasksResetAt: z.string(),
+  openTasks: z.number(),
+  totalTasks: z.number(),
+  seats: z.string(),
+  groups: z.string(),
+  apiKeys: z.string(),
+  rateLimitPerSecond: z.number()
+});
+var getWorkspaceUsageOutputSchema = z.union([
+  withAgentOnlyFields({
+    usage: workspaceUsageEntitySchema
+  }),
+  agentAdminErrorResultSchema
+]);
+
 // src/eve/index.ts
 var ROBOTROCK_READY_HOOK_SLUG = "robotrock-ready";
 
@@ -703,154 +1049,10 @@ function robotrockEveChannel(options) {
 }
 
 // src/schemas/index.ts
-import { z as z4 } from "zod";
-
-// ../core/src/utils/safe-url.ts
-var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
-  "localhost",
-  "metadata.google.internal",
-  "metadata.goog"
-]);
-function normalizeHostname(hostname) {
-  return hostname.toLowerCase().replace(/^\[|\]$/g, "");
-}
-function isBlockedIpv4(host) {
-  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
-  if (!match) {
-    return false;
-  }
-  const octets = match.slice(1, 5).map((part) => Number(part));
-  if (octets.some((octet) => Number.isNaN(octet) || octet < 0 || octet > 255)) {
-    return true;
-  }
-  const [a, b, _c, _d] = octets;
-  if (a === void 0 || b === void 0) {
-    return true;
-  }
-  if (a === 127 || a === 0) return true;
-  if (a === 10) return true;
-  if (a === 169 && b === 254) return true;
-  if (a === 192 && b === 168) return true;
-  if (a === 172 && b >= 16 && b <= 31) return true;
-  if (a === 100 && b >= 64 && b <= 127) return true;
-  return false;
-}
-function ipv4FromNumericHost(host) {
-  if (/^\d+$/.test(host)) {
-    const num = Number(host);
-    if (!Number.isFinite(num) || num < 0 || num > 4294967295) {
-      return null;
-    }
-    const a = num >>> 24 & 255;
-    const b = num >>> 16 & 255;
-    const c = num >>> 8 & 255;
-    const d = num & 255;
-    return `${a}.${b}.${c}.${d}`;
-  }
-  const hexMatch = /^0x([0-9a-f]{1,8})$/i.exec(host);
-  if (hexMatch) {
-    const num = Number.parseInt(hexMatch[1], 16);
-    if (!Number.isFinite(num) || num < 0 || num > 4294967295) {
-      return null;
-    }
-    const a = num >>> 24 & 255;
-    const b = num >>> 16 & 255;
-    const c = num >>> 8 & 255;
-    const d = num & 255;
-    return `${a}.${b}.${c}.${d}`;
-  }
-  return null;
-}
-function isBlockedIpv4Mapped(host) {
-  const mappedDotted = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/i.exec(host);
-  if (mappedDotted) {
-    return isBlockedIpv4(mappedDotted[1]);
-  }
-  const mappedHex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i.exec(host);
-  if (mappedHex) {
-    const high = Number.parseInt(mappedHex[1], 16);
-    const low = Number.parseInt(mappedHex[2], 16);
-    if (Number.isFinite(high) && Number.isFinite(low)) {
-      const a = high >> 8 & 255;
-      const b = high & 255;
-      const c = low >> 8 & 255;
-      const d = low & 255;
-      return isBlockedIpv4(`${a}.${b}.${c}.${d}`);
-    }
-  }
-  return false;
-}
-function isBlockedIpv6(host) {
-  if (host === "::1" || host === "0:0:0:0:0:0:0:1") {
-    return true;
-  }
-  if (host.startsWith("fc") || host.startsWith("fd")) {
-    return true;
-  }
-  if (host.startsWith("fe80:")) {
-    return true;
-  }
-  if (isBlockedIpv4Mapped(host)) {
-    return true;
-  }
-  return false;
-}
-function isBlockedHostname(hostname) {
-  const host = normalizeHostname(hostname);
-  if (!host) {
-    return true;
-  }
-  if (BLOCKED_HOSTNAMES.has(host)) {
-    return true;
-  }
-  if (host.endsWith(".localhost") || host.endsWith(".local")) {
-    return true;
-  }
-  const numericIpv4 = ipv4FromNumericHost(host);
-  if (numericIpv4 && isBlockedIpv4(numericIpv4)) {
-    return true;
-  }
-  return isBlockedIpv4(host) || isBlockedIpv6(host);
-}
-function isLoopbackHandlerUrl(urlString) {
-  let url;
-  try {
-    url = new URL(urlString);
-  } catch {
-    return false;
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    return false;
-  }
-  if (url.username || url.password) {
-    return false;
-  }
-  const host = url.hostname.toLowerCase();
-  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]" || host.endsWith(".localhost");
-}
-function isAllowedHandlerUrl(urlString) {
-  return isPublicHttpUrl(urlString) || isLoopbackHandlerUrl(urlString);
-}
-function isPublicHttpUrl(urlString) {
-  let url;
-  try {
-    url = new URL(urlString);
-  } catch {
-    return false;
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    return false;
-  }
-  if (url.username || url.password) {
-    return false;
-  }
-  return !isBlockedHostname(url.hostname);
-}
-var PUBLIC_HTTP_URL_ERROR = "URL must be a public http:// or https:// address";
-var HANDLER_URL_ERROR = "Handler URL must be a public or loopback http:// or https:// address";
+import { z as z5 } from "zod";
 
 // ../core/src/schemas/task.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // ../core/src/schemas/context-urls.ts
 function resolveLinkUrl(value) {
@@ -906,67 +1108,67 @@ function validateContextPublicUrls(context) {
 }
 
 // ../core/src/schemas/task.ts
-var safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {
+var safeUrlSchema = z2.string().refine((url) => isPublicHttpUrl(url), {
   message: PUBLIC_HTTP_URL_ERROR
 });
-var handlerUrlSchema = z.string().refine((url) => isAllowedHandlerUrl(url), {
+var handlerUrlSchema = z2.string().refine((url) => isAllowedHandlerUrl(url), {
   message: HANDLER_URL_ERROR
 });
-var jsonSchema7Schema = z.custom(
+var jsonSchema7Schema = z2.custom(
   (val) => typeof val === "object" && val !== null,
   { message: "Must be a valid JSON Schema object" }
 );
-var uiSchemaSchema = z.custom((val) => typeof val === "object" && val !== null, {
+var uiSchemaSchema = z2.custom((val) => typeof val === "object" && val !== null, {
   message: "Must be a valid UiSchema object"
 });
-var webhookHandlerSchema = z.object({
-  type: z.literal("webhook"),
+var webhookHandlerSchema = z2.object({
+  type: z2.literal("webhook"),
   url: handlerUrlSchema,
-  headers: z.record(z.string(), z.string())
+  headers: z2.record(z2.string(), z2.string())
 });
 var triggerHandlerSchema = webhookHandlerSchema.extend({
-  type: z.literal("trigger"),
-  tokenId: z.string().min(1)
+  type: z2.literal("trigger"),
+  tokenId: z2.string().min(1)
 });
-var handlerSchema = z.discriminatedUnion("type", [webhookHandlerSchema, triggerHandlerSchema]);
-var taskActionInputSchema = z.object({
-  id: z.string().min(1),
-  title: z.string().min(1),
-  description: z.string().optional(),
+var handlerSchema = z2.discriminatedUnion("type", [webhookHandlerSchema, triggerHandlerSchema]);
+var taskActionInputSchema = z2.object({
+  id: z2.string().min(1),
+  title: z2.string().min(1),
+  description: z2.string().optional(),
   schema: jsonSchema7Schema.optional(),
   ui: uiSchemaSchema.optional(),
-  data: z.record(z.string(), z.unknown()).optional()
+  data: z2.record(z2.string(), z2.unknown()).optional()
 });
 var taskActionSchema = taskActionInputSchema.extend({
   // Optional handlers for this action - if present, must have at least 1
-  handlers: z.array(handlerSchema).min(1).optional()
-});
-var uiFieldSchemaSchema = z.object({
-  "ui:widget": z.string().optional(),
-  "ui:title": z.string().optional(),
-  "ui:description": z.string().optional(),
-  "ui:options": z.record(z.string(), z.unknown()).optional(),
-  items: z.lazy(() => z.record(z.string(), uiFieldSchemaSchema)).optional()
+  handlers: z2.array(handlerSchema).min(1).optional()
+});
+var uiFieldSchemaSchema = z2.object({
+  "ui:widget": z2.string().optional(),
+  "ui:title": z2.string().optional(),
+  "ui:description": z2.string().optional(),
+  "ui:options": z2.record(z2.string(), z2.unknown()).optional(),
+  items: z2.lazy(() => z2.record(z2.string(), uiFieldSchemaSchema)).optional()
 }).passthrough();
-var contextUiSchema = z.record(z.string(), uiFieldSchemaSchema).optional();
-var contextDataSchema = z.object({
-  data: z.record(z.string(), z.unknown()),
+var contextUiSchema = z2.record(z2.string(), uiFieldSchemaSchema).optional();
+var contextDataSchema = z2.object({
+  data: z2.record(z2.string(), z2.unknown()),
   ui: contextUiSchema
 }).optional();
 var TASK_CONTEXT_FORMAT_VERSION = 2;
-var taskContextObjectBaseSchema = z.object({
+var taskContextObjectBaseSchema = z2.object({
   /** Source application id; omitted tasks are grouped in the default inbox. */
-  app: z.string().min(1).optional(),
-  type: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().optional(),
-  validUntil: z.string().optional(),
+  app: z2.string().min(1).optional(),
+  type: z2.string().min(1),
+  name: z2.string().min(1),
+  description: z2.string().optional(),
+  validUntil: z2.string().optional(),
   context: contextDataSchema,
   /** Task context wire format version. @default 2 */
-  contextVersion: z.literal(2).optional(),
+  contextVersion: z2.literal(2).optional(),
   /** @deprecated Use `contextVersion`. Accepted on ingest only. */
-  version: z.literal(2).optional(),
-  actions: z.array(taskActionSchema).min(1, "At least one action is required")
+  version: z2.literal(2).optional(),
+  actions: z2.array(taskActionSchema).min(1, "At least one action is required")
 });
 function normalizeTaskContextVersion(data) {
   const { version: legacyVersion, contextVersion, ...rest } = data;
@@ -982,7 +1184,7 @@ function refineContextPublicUrls(data, ctx) {
   const error = validateContextPublicUrls(data.context);
   if (error) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: error,
       path: ["context"]
     });
@@ -991,9 +1193,9 @@ function refineContextPublicUrls(data, ctx) {
 var taskContextSchema = taskContextObjectSchema.superRefine(
   refineContextPublicUrls
 );
-var assignToSchema = z.object({
-  users: z.array(z.string().email()).optional(),
-  groups: z.array(z.string().min(1)).optional()
+var assignToSchema = z2.object({
+  users: z2.array(z2.string().email()).optional(),
+  groups: z2.array(z2.string().min(1)).optional()
 }).refine(
   (data) => {
     const groups = data.groups ?? [];
@@ -1004,7 +1206,7 @@ var assignToSchema = z.object({
   },
   { message: 'Cannot combine "all" with other group slugs' }
 );
-var threadUpdateMessageSchema = z.string().min(1).max(500);
+var threadUpdateMessageSchema = z2.string().min(1).max(500);
 var threadUpdateStatuses = [
   "info",
   "queued",
@@ -1014,16 +1216,16 @@ var threadUpdateStatuses = [
   "failed",
   "cancelled"
 ];
-var threadUpdateStatusSchema = z.enum(threadUpdateStatuses);
-var threadUpdateInputSchema = z.object({
+var threadUpdateStatusSchema = z2.enum(threadUpdateStatuses);
+var threadUpdateInputSchema = z2.object({
   message: threadUpdateMessageSchema,
   status: threadUpdateStatusSchema.optional()
 });
 var taskPriorities = ["low", "normal", "high", "urgent"];
-var taskPrioritySchema = z.enum(taskPriorities);
-var agentTelemetrySchema = z.object({
+var taskPrioritySchema = z2.enum(taskPriorities);
+var agentTelemetrySchema = z2.object({
   /** Agent or app version (semver, git SHA, deploy tag — caller-defined). */
-  version: z.string().min(1)
+  version: z2.string().min(1)
 });
 var createTaskBodySchema = taskContextObjectBaseSchema.extend({
   assignTo: assignToSchema.optional(),
@@ -1031,7 +1233,7 @@ var createTaskBodySchema = taskContextObjectBaseSchema.extend({
    * Groups related tasks together. When omitted, the server generates one and
    * returns it so the caller can reuse it on later tasks in the same thread.
    */
-  threadId: z.string().min(1).optional(),
+  threadId: z2.string().min(1).optional(),
   /**
    * Optional thread priority. When set, applies to the whole thread and
    * overwrites any previous priority. Omit on later tasks to leave unchanged.
@@ -1045,280 +1247,346 @@ var createTaskBodySchema = taskContextObjectBaseSchema.extend({
   /** Agent release version — not shown in inbox UI. */
   agent: agentTelemetrySchema.optional()
 }).transform(normalizeTaskContextVersion).superRefine(refineContextPublicUrls);
-var agentChatSeedActionSchema = z.object({
+var agentChatSeedActionSchema = z2.object({
   /** Stable action id echoed back on submit; auto-derived from title when omitted. */
-  id: z.string().min(1).optional(),
-  title: z.string().min(1),
-  description: z.string().optional(),
+  id: z2.string().min(1).optional(),
+  title: z2.string().min(1),
+  description: z2.string().optional(),
   /** JSON Schema object for the form fields. */
-  schema: z.record(z.string(), z.unknown()).optional(),
+  schema: z2.record(z2.string(), z2.unknown()).optional(),
   /** RJSF ui schema overrides (ui:widget, ui:enumNames, etc.). */
-  ui: z.record(z.string(), z.unknown()).optional(),
+  ui: z2.record(z2.string(), z2.unknown()).optional(),
   /** Optional default field values. */
-  data: z.record(z.string(), z.unknown()).optional()
+  data: z2.record(z2.string(), z2.unknown()).optional()
 });
-var agentChatSeedMessageSchema = z.object({
-  role: z.enum(["user", "assistant"]),
-  text: z.string().min(1),
+var agentChatSeedMessageSchema = z2.object({
+  role: z2.enum(["user", "assistant"]),
+  text: z2.string().min(1),
   /** Optional display-name override for the message sender. */
-  senderName: z.string().min(1).optional(),
+  senderName: z2.string().min(1).optional(),
   /**
    * Optional structured input request rendered as a styled RobotRock action
    * widget below the message text. Use this instead of asking the user to reply
    * in plain text so the request is always a proper action form.
    */
-  requestActionInput: z.object({
-    prompt: z.string().optional(),
+  requestActionInput: z2.object({
+    prompt: z2.string().optional(),
     action: agentChatSeedActionSchema
   }).optional()
 });
-var eveAgentChatTransportSchema = z.object({
-  kind: z.literal("eve"),
-  chatId: z.string().min(1),
-  baseUrl: z.string().url(),
-  sessionId: z.string().optional(),
-  continuationToken: z.string().optional(),
-  streamIndex: z.number().int().nonnegative().optional(),
-  isStreaming: z.boolean().optional()
+var eveAgentChatTransportSchema = z2.object({
+  kind: z2.literal("eve"),
+  chatId: z2.string().min(1),
+  baseUrl: z2.string().url(),
+  sessionId: z2.string().optional(),
+  continuationToken: z2.string().optional(),
+  streamIndex: z2.number().int().nonnegative().optional(),
+  isStreaming: z2.boolean().optional()
 });
-var createAgentChatBodySchema = z.object({
+var createAgentChatBodySchema = z2.object({
   /** Agent id (eve agent name). Required unless `parentChatId` is set. */
-  agentIdentifier: z.string().min(1).optional(),
+  agentIdentifier: z2.string().min(1).optional(),
   /** Inherit tenant/connection/agent from an existing chat (agent-spawned chats). */
-  parentChatId: z.string().min(1).optional(),
+  parentChatId: z2.string().min(1).optional(),
   /** Convex tenantEveConnections id; resolved from the tenant when omitted. */
-  eveConnectionId: z.string().min(1).optional(),
+  eveConnectionId: z2.string().min(1).optional(),
   /** Source application id; groups the chat under an inbox section. */
-  app: z.string().min(1).optional(),
+  app: z2.string().min(1).optional(),
   /** Email of the user who owns the chat. Required unless `parentChatId` is set. */
-  ownerEmail: z.string().email().optional(),
-  title: z.string().min(1),
-  messages: z.array(agentChatSeedMessageSchema).default([]),
+  ownerEmail: z2.string().email().optional(),
+  title: z2.string().min(1),
+  messages: z2.array(agentChatSeedMessageSchema).default([]),
   /** Provenance label stored on the session ("cron" | "agent" | ...). */
-  source: z.string().min(1).optional()
+  source: z2.string().min(1).optional()
 }).refine((data) => Boolean(data.agentIdentifier || data.parentChatId), {
   message: "Provide either agentIdentifier or parentChatId"
 }).refine((data) => Boolean(data.ownerEmail || data.parentChatId), {
   message: "Provide ownerEmail unless parentChatId is set"
 });
-var agentChatAuditToolBodySchema = z.object({
-  eveSessionId: z.string().min(1),
-  userId: z.string().min(1),
-  toolCallId: z.string().min(1),
-  toolName: z.string().min(1),
-  input: z.record(z.string(), z.unknown()).default({}),
-  success: z.boolean(),
-  status: z.enum(["completed", "failed", "rejected"]),
-  error: z.string().optional(),
-  idempotencyKey: z.string().optional()
-});
-var agentChatAuditInputBodySchema = z.object({
-  eveSessionId: z.string().min(1),
-  userId: z.string().min(1),
-  actionId: z.string().min(1),
-  actionTitle: z.string().optional(),
-  prompt: z.string().optional(),
-  data: z.record(z.string(), z.unknown()).optional(),
-  idempotencyKey: z.string().optional(),
+var agentChatAuditToolBodySchema = z2.object({
+  eveSessionId: z2.string().min(1),
+  userId: z2.string().min(1),
+  toolCallId: z2.string().min(1),
+  toolName: z2.string().min(1),
+  input: z2.record(z2.string(), z2.unknown()).default({}),
+  success: z2.boolean(),
+  status: z2.enum(["completed", "failed", "rejected"]),
+  error: z2.string().optional(),
+  idempotencyKey: z2.string().optional()
+});
+var agentChatAuditInputBodySchema = z2.object({
+  eveSessionId: z2.string().min(1),
+  userId: z2.string().min(1),
+  actionId: z2.string().min(1),
+  actionTitle: z2.string().optional(),
+  prompt: z2.string().optional(),
+  data: z2.record(z2.string(), z2.unknown()).optional(),
+  idempotencyKey: z2.string().optional(),
   /** Eve input request id — used to merge staged HITL metadata. */
-  requestId: z.string().optional(),
+  requestId: z2.string().optional(),
   /** Eve tool call id — fallback lookup for staged HITL metadata. */
-  toolCallId: z.string().optional()
+  toolCallId: z2.string().optional()
 });
-var eveHitlStagedOptionSchema = z.object({
-  id: z.string(),
-  label: z.string()
+var eveHitlStagedOptionSchema = z2.object({
+  id: z2.string(),
+  label: z2.string()
 });
-var agentChatStageHitlBodySchema = z.object({
-  eveSessionId: z.string().min(1),
-  requests: z.array(
-    z.object({
-      requestId: z.string().min(1),
-      toolCallId: z.string().min(1),
-      toolName: z.string().min(1),
-      prompt: z.string().min(1),
-      display: z.enum(["confirmation", "select", "text"]).optional(),
-      allowFreeform: z.boolean().optional(),
-      options: z.array(eveHitlStagedOptionSchema).optional(),
-      toolInput: z.record(z.string(), z.unknown()).optional()
+var agentChatStageHitlBodySchema = z2.object({
+  eveSessionId: z2.string().min(1),
+  requests: z2.array(
+    z2.object({
+      requestId: z2.string().min(1),
+      toolCallId: z2.string().min(1),
+      toolName: z2.string().min(1),
+      prompt: z2.string().min(1),
+      display: z2.enum(["confirmation", "select", "text"]).optional(),
+      allowFreeform: z2.boolean().optional(),
+      options: z2.array(eveHitlStagedOptionSchema).optional(),
+      toolInput: z2.record(z2.string(), z2.unknown()).optional()
     })
   )
 });
-var agentChatLinkTaskBodySchema = z.object({
-  eveSessionId: z.string().min(1),
-  publicTaskId: z.string().min(1),
-  toolCallId: z.string().min(1)
+var agentChatLinkTaskBodySchema = z2.object({
+  eveSessionId: z2.string().min(1),
+  publicTaskId: z2.string().min(1),
+  toolCallId: z2.string().min(1)
+});
+var AGENT_FILE_TAGS_MAX = 20;
+var AGENT_FILE_TAG_MAX_LENGTH = 64;
+function normalizeAgentFileTags(tags) {
+  if (!tags?.length) return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of tags) {
+    const tag = raw.trim().toLowerCase().slice(0, AGENT_FILE_TAG_MAX_LENGTH);
+    if (!tag || seen.has(tag)) continue;
+    seen.add(tag);
+    out.push(tag);
+    if (out.length >= AGENT_FILE_TAGS_MAX) break;
+  }
+  return out.length > 0 ? out : void 0;
+}
+var agentChatUploadImageBodySchema = z2.object({
+  mediaType: z2.string().min(1),
+  /** Raw base64 (no data: URL prefix). */
+  base64: z2.string().min(1),
+  chatId: z2.string().min(1).optional(),
+  publicTaskId: z2.string().min(1).optional(),
+  source: z2.string().min(1).optional(),
+  /** Display / search name (e.g. `sunset-robot.png`). */
+  filename: z2.string().min(1).max(255).optional(),
+  /** Human-readable description (e.g. generation prompt). */
+  description: z2.string().min(1).max(2e3).optional(),
+  /**
+   * Optional labels for later grouping/filtering.
+   * Normalized to lowercase trimmed unique strings (max 20, 64 chars each).
+   */
+  tags: z2.array(z2.string().min(1).max(AGENT_FILE_TAG_MAX_LENGTH)).max(AGENT_FILE_TAGS_MAX).optional().transform((tags) => normalizeAgentFileTags(tags))
+}).refine((data) => Boolean(data.chatId || data.publicTaskId), {
+  message: "Provide chatId and/or publicTaskId"
 });
 
 // ../core/src/schemas/tool-result-display.ts
-import { z as z2 } from "zod";
-var toolDisplayMetadataSchema = z2.object({
-  widget: z2.string().optional(),
-  title: z2.string().optional(),
-  description: z2.string().optional()
+import { z as z3 } from "zod";
+var toolDisplayMetadataSchema = z3.object({
+  widget: z3.string().optional(),
+  title: z3.string().optional(),
+  description: z3.string().optional()
 });
-var toolDisplayEnvelopeSchema = z2.object({
+var toolDisplayEnvelopeSchema = z3.object({
   display: toolDisplayMetadataSchema.optional(),
-  data: z2.record(z2.string(), z2.unknown()),
-  ui: z2.record(
-    z2.string(),
-    z2.object({
-      "ui:widget": z2.string().optional(),
-      "ui:title": z2.string().optional(),
-      "ui:description": z2.string().optional(),
-      "ui:options": z2.record(z2.string(), z2.unknown()).optional()
+  data: z3.record(z3.string(), z3.unknown()),
+  ui: z3.record(
+    z3.string(),
+    z3.object({
+      "ui:widget": z3.string().optional(),
+      "ui:title": z3.string().optional(),
+      "ui:description": z3.string().optional(),
+      "ui:options": z3.record(z3.string(), z3.unknown()).optional()
     }).passthrough()
   ).optional()
 });
 
 // ../core/src/schemas/agent-admin.ts
-import { z as z3 } from "zod";
-var tenantRoleSchema = z3.enum(["admin", "member"]);
-var agentAdminUserSchema = z3.object({
-  id: z3.string(),
-  email: z3.string().email(),
-  name: z3.string()
-});
-var agentAdminMemberSchema = z3.object({
-  userId: z3.string(),
-  role: z3.string(),
-  membershipKind: z3.enum(["team", "assignee"]),
-  hasLoggedIn: z3.boolean(),
+import { z as z4 } from "zod";
+var tenantRoleSchema = z4.enum(["admin", "member"]);
+var agentAdminUserSchema = z4.object({
+  id: z4.string(),
+  email: z4.string().email(),
+  name: z4.string(),
+  profilePictureUrl: z4.string().nullable().optional()
+});
+var agentAdminMemberSchema = z4.object({
+  userId: z4.string(),
+  role: z4.string(),
+  membershipKind: z4.enum(["team", "assignee"]),
+  hasLoggedIn: z4.boolean(),
   user: agentAdminUserSchema
 });
-var agentAdminGroupSchema = z3.object({
-  id: z3.string(),
-  name: z3.string(),
-  slug: z3.string(),
-  description: z3.string().nullable(),
-  memberCount: z3.number().optional()
+var agentAdminGroupSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  slug: z4.string(),
+  description: z4.string().nullable(),
+  memberCount: z4.number().optional()
 });
 var agentAdminGroupDetailSchema = agentAdminGroupSchema.extend({
-  members: z3.array(
-    z3.object({
-      userId: z3.string(),
+  members: z4.array(
+    z4.object({
+      userId: z4.string(),
       user: agentAdminUserSchema
     })
   )
 });
-var agentAdminTaskSummarySchema = z3.object({
-  id: z3.string(),
-  convexId: z3.string(),
-  status: z3.string(),
-  type: z3.string().nullable(),
-  name: z3.string().nullable(),
-  description: z3.string().nullable(),
-  validUntil: z3.number(),
-  createdAt: z3.number(),
-  threadPriority: z3.string().nullable(),
-  handledByUserId: z3.string().nullable()
-});
-var inviteMemberBodySchema = z3.object({
-  email: z3.string().email(),
+var agentAdminTaskSummarySchema = z4.object({
+  id: z4.string(),
+  convexId: z4.string(),
+  status: z4.string(),
+  type: z4.string().nullable(),
+  name: z4.string().nullable(),
+  description: z4.string().nullable(),
+  validUntil: z4.number(),
+  createdAt: z4.number(),
+  threadPriority: z4.string().nullable(),
+  handledByUserId: z4.string().nullable()
+});
+var inviteMemberBodySchema = z4.object({
+  email: z4.string().email(),
   role: tenantRoleSchema.optional()
 });
-var updateMemberRoleBodySchema = z3.object({
+var updateMemberRoleBodySchema = z4.object({
   role: tenantRoleSchema
 });
-var createGroupBodySchema = z3.object({
-  name: z3.string().min(1),
-  description: z3.string().optional()
+var createGroupBodySchema = z4.object({
+  name: z4.string().min(1),
+  description: z4.string().optional()
 });
-var updateGroupBodySchema = z3.object({
-  name: z3.string().min(1).optional(),
-  description: z3.string().optional()
+var updateGroupBodySchema = z4.object({
+  name: z4.string().min(1).optional(),
+  description: z4.string().optional()
+});
+var addGroupMemberBodySchema = z4.object({
+  userId: z4.string().min(1).describe("Convex user id or member email.")
+});
+var listTasksQuerySchema = z4.object({
+  statusFilter: z4.enum(["all", "open", "handled", "expired"]).optional(),
+  typeFilter: z4.string().optional(),
+  appFilter: z4.string().optional(),
+  sortField: z4.enum(["type", "date", "status", "validUntil"]).optional(),
+  sortDirection: z4.enum(["asc", "desc"]).optional(),
+  limit: z4.coerce.number().int().positive().max(100).optional(),
+  cursor: z4.string().optional()
 });
-var addGroupMemberBodySchema = z3.object({
-  userId: z3.string().min(1).describe("Convex user id or member email.")
-});
-var listTasksQuerySchema = z3.object({
-  statusFilter: z3.enum(["all", "open", "handled", "expired"]).optional(),
-  typeFilter: z3.string().optional(),
-  appFilter: z3.string().optional(),
-  sortField: z3.enum(["type", "date", "status", "validUntil"]).optional(),
-  sortDirection: z3.enum(["asc", "desc"]).optional(),
-  limit: z3.coerce.number().int().positive().max(100).optional(),
-  cursor: z3.string().optional()
-});
-var searchTasksQuerySchema = z3.object({
-  q: z3.string().min(1),
-  limit: z3.coerce.number().int().positive().max(100).optional()
-});
-var assignTasksResultSchema = z3.object({
-  taskId: z3.string(),
-  success: z3.boolean(),
-  message: z3.string().optional(),
-  name: z3.string().nullable().optional(),
-  description: z3.string().nullable().optional(),
-  type: z3.string().nullable().optional()
-});
-var assignTasksResponseSchema = z3.object({
-  results: z3.array(assignTasksResultSchema)
-});
-var assignTasksBodySchema = z3.object({
-  taskIds: z3.array(z3.string().min(1)).min(1).max(100),
+var searchTasksQuerySchema = z4.object({
+  q: z4.string().min(1),
+  limit: z4.coerce.number().int().positive().max(100).optional()
+});
+var assignTasksResultSchema = z4.object({
+  taskId: z4.string(),
+  success: z4.boolean(),
+  message: z4.string().optional(),
+  name: z4.string().nullable().optional(),
+  description: z4.string().nullable().optional(),
+  type: z4.string().nullable().optional()
+});
+var assignTasksResponseSchema = z4.object({
+  results: z4.array(assignTasksResultSchema)
+});
+var assignTasksBodySchema = z4.object({
+  taskIds: z4.array(z4.string().min(1)).min(1).max(100),
   assignTo: assignToSchema.refine(
     (value) => (value.users?.length ?? 0) > 0 || (value.groups?.length ?? 0) > 0,
     { message: "assignTo needs at least one user email or group slug." }
   )
 });
+var agentAdminPlanLimitsSchema = z4.object({
+  tasksPerDay: z4.number(),
+  members: z4.number(),
+  apiKeys: z4.number(),
+  groups: z4.number(),
+  auditLogRetention: z4.number(),
+  rateLimitPerSecond: z4.number(),
+  taskRetentionDays: z4.number()
+});
+var agentAdminUsageSchema = z4.object({
+  workspace: z4.string(),
+  planName: z4.string(),
+  planType: z4.string(),
+  trialState: z4.enum(["none", "active", "expired"]),
+  daysRemaining: z4.number().nullable(),
+  isPaidPro: z4.boolean(),
+  subscriptionStatus: z4.string().nullable(),
+  tasksToday: z4.number(),
+  maxTasksPerDay: z4.number().nullable(),
+  tasksResetAt: z4.number(),
+  openTasks: z4.number(),
+  totalTasks: z4.number(),
+  seatsCurrent: z4.number(),
+  seatsMax: z4.number().nullable(),
+  groupsCurrent: z4.number(),
+  groupsMax: z4.number().nullable(),
+  apiKeysCurrent: z4.number(),
+  apiKeysMax: z4.number().nullable(),
+  rateLimitPerSecond: z4.number(),
+  limits: agentAdminPlanLimitsSchema
+});
 
 // src/schemas/index.ts
-var handlerUrlSchema2 = z4.string().refine((url) => isAllowedHandlerUrl(url), {
+var handlerUrlSchema2 = z5.string().refine((url) => isAllowedHandlerUrl(url), {
   message: HANDLER_URL_ERROR
 });
-var jsonSchema7Schema2 = z4.custom(
+var jsonSchema7Schema2 = z5.custom(
   (val) => typeof val === "object" && val !== null,
   { message: "Must be a valid JSON Schema object" }
 );
-var uiSchemaSchema2 = z4.custom((val) => typeof val === "object" && val !== null, {
+var uiSchemaSchema2 = z5.custom((val) => typeof val === "object" && val !== null, {
   message: "Must be a valid UiSchema object"
 });
-var webhookHandlerSchema2 = z4.object({
-  type: z4.literal("webhook"),
+var webhookHandlerSchema2 = z5.object({
+  type: z5.literal("webhook"),
   url: handlerUrlSchema2,
-  headers: z4.record(z4.string(), z4.string())
+  headers: z5.record(z5.string(), z5.string())
 });
 var triggerHandlerSchema2 = webhookHandlerSchema2.extend({
-  type: z4.literal("trigger"),
-  tokenId: z4.string().min(1)
-});
-var handlerSchema2 = z4.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
-var taskActionInputSchema2 = z4.object({
-  id: z4.string().min(1),
-  title: z4.string().min(1),
-  description: z4.string().optional(),
+  type: z5.literal("trigger"),
+  tokenId: z5.string().min(1)
+});
+var handlerSchema2 = z5.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
+var taskActionInputSchema2 = z5.object({
+  id: z5.string().min(1),
+  title: z5.string().min(1),
+  description: z5.string().optional(),
   schema: jsonSchema7Schema2.optional(),
   ui: uiSchemaSchema2.optional(),
-  data: z4.record(z4.string(), z4.unknown()).optional()
+  data: z5.record(z5.string(), z5.unknown()).optional()
 });
 var taskActionSchema2 = taskActionInputSchema2.extend({
-  handlers: z4.array(handlerSchema2).min(1).optional()
-});
-var uiFieldSchemaSchema2 = z4.object({
-  "ui:widget": z4.string().optional(),
-  "ui:title": z4.string().optional(),
-  "ui:description": z4.string().optional(),
-  "ui:options": z4.record(z4.string(), z4.unknown()).optional(),
-  items: z4.lazy(() => z4.record(z4.string(), uiFieldSchemaSchema2)).optional()
+  handlers: z5.array(handlerSchema2).min(1).optional()
+});
+var uiFieldSchemaSchema2 = z5.object({
+  "ui:widget": z5.string().optional(),
+  "ui:title": z5.string().optional(),
+  "ui:description": z5.string().optional(),
+  "ui:options": z5.record(z5.string(), z5.unknown()).optional(),
+  items: z5.lazy(() => z5.record(z5.string(), uiFieldSchemaSchema2)).optional()
 }).passthrough();
-var contextUiSchema2 = z4.record(z4.string(), uiFieldSchemaSchema2).optional();
-var contextDataSchema2 = z4.object({
-  data: z4.record(z4.string(), z4.unknown()),
+var contextUiSchema2 = z5.record(z5.string(), uiFieldSchemaSchema2).optional();
+var contextDataSchema2 = z5.object({
+  data: z5.record(z5.string(), z5.unknown()),
   ui: contextUiSchema2
 }).optional();
 var TASK_CONTEXT_FORMAT_VERSION2 = 2;
-var taskContextObjectBaseSchema2 = z4.object({
-  app: z4.string().min(1).optional(),
-  type: z4.string().min(1),
-  name: z4.string().min(1),
-  description: z4.string().optional(),
-  validUntil: z4.string().optional(),
+var taskContextObjectBaseSchema2 = z5.object({
+  app: z5.string().min(1).optional(),
+  type: z5.string().min(1),
+  name: z5.string().min(1),
+  description: z5.string().optional(),
+  validUntil: z5.string().optional(),
   context: contextDataSchema2,
-  contextVersion: z4.literal(2).optional(),
+  contextVersion: z5.literal(2).optional(),
   /** @deprecated Use `contextVersion`. Accepted on ingest only. */
-  version: z4.literal(2).optional(),
-  actions: z4.array(taskActionSchema2).min(1, "At least one action is required")
+  version: z5.literal(2).optional(),
+  actions: z5.array(taskActionSchema2).min(1, "At least one action is required")
 });
 function normalizeTaskContextVersion2(data) {
   const { version: legacyVersion, contextVersion, ...rest } = data;
@@ -1334,7 +1602,7 @@ function refineContextPublicUrls2(data, ctx) {
   const error = validateContextPublicUrls(data.context);
   if (error) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       message: error,
       path: ["context"]
     });
@@ -1343,9 +1611,9 @@ function refineContextPublicUrls2(data, ctx) {
 var taskContextSchema2 = taskContextObjectSchema2.superRefine(
   refineContextPublicUrls2
 );
-var assignToSchema2 = z4.object({
-  users: z4.array(z4.string().email()).optional(),
-  groups: z4.array(z4.string().min(1)).optional()
+var assignToSchema2 = z5.object({
+  users: z5.array(z5.string().email()).optional(),
+  groups: z5.array(z5.string().min(1)).optional()
 }).refine(
   (data) => {
     const groups = data.groups ?? [];
@@ -1356,7 +1624,7 @@ var assignToSchema2 = z4.object({
   },
   { message: 'Cannot combine "all" with other group slugs' }
 );
-var threadUpdateMessageSchema2 = z4.string().min(1).max(500);
+var threadUpdateMessageSchema2 = z5.string().min(1).max(500);
 var threadUpdateStatuses2 = [
   "info",
   "queued",
@@ -1366,15 +1634,15 @@ var threadUpdateStatuses2 = [
   "failed",
   "cancelled"
 ];
-var threadUpdateStatusSchema2 = z4.enum(threadUpdateStatuses2);
-var threadUpdateInputSchema2 = z4.object({
+var threadUpdateStatusSchema2 = z5.enum(threadUpdateStatuses2);
+var threadUpdateInputSchema2 = z5.object({
   message: threadUpdateMessageSchema2,
   status: threadUpdateStatusSchema2.optional()
 });
 var taskPriorities2 = ["low", "normal", "high", "urgent"];
-var taskPrioritySchema2 = z4.enum(taskPriorities2);
-var agentTelemetrySchema2 = z4.object({
-  version: z4.string().min(1)
+var taskPrioritySchema2 = z5.enum(taskPriorities2);
+var agentTelemetrySchema2 = z5.object({
+  version: z5.string().min(1)
 });
 var createTaskBodySchema2 = taskContextObjectBaseSchema2.extend({
   assignTo: assignToSchema2.optional(),
@@ -1382,7 +1650,7 @@ var createTaskBodySchema2 = taskContextObjectBaseSchema2.extend({
    * Groups related tasks together. When omitted, the server generates one and
    * returns it so the caller can reuse it on later tasks in the same thread.
    */
-  threadId: z4.string().min(1).optional(),
+  threadId: z5.string().min(1).optional(),
   /**
    * Optional thread priority. When set, applies to the whole thread and
    * overwrites any previous priority. Omit on later tasks to leave unchanged.
@@ -1417,7 +1685,7 @@ var HANDLER_RETRY_DELAYS_MS = [
 var HANDLER_MAX_ATTEMPTS = HANDLER_RETRY_DELAYS_MS.length + 1;
 
 // ../core/src/attribution/index.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // ../core/src/app-url.ts
 var PRODUCTION_APP_URL = "https://app.robotrock.io";
@@ -1444,16 +1712,16 @@ function getRobotRockApiBaseUrl() {
 
 // ../core/src/attribution/index.ts
 var ATTRIBUTION_COOKIE_MAX_AGE = 60 * 60 * 24 * 90;
-var attributionSchema = z5.object({
-  utmSource: z5.string().optional(),
-  utmMedium: z5.string().optional(),
-  utmCampaign: z5.string().optional(),
-  utmContent: z5.string().optional(),
-  utmTerm: z5.string().optional(),
-  gclid: z5.string().optional(),
-  landingUrl: z5.string().optional(),
-  referrer: z5.string().optional(),
-  capturedAt: z5.number()
+var attributionSchema = z6.object({
+  utmSource: z6.string().optional(),
+  utmMedium: z6.string().optional(),
+  utmCampaign: z6.string().optional(),
+  utmContent: z6.string().optional(),
+  utmTerm: z6.string().optional(),
+  gclid: z6.string().optional(),
+  landingUrl: z6.string().optional(),
+  referrer: z6.string().optional(),
+  capturedAt: z6.number()
 });
 
 // src/approval-result.ts
@@ -1565,7 +1833,11 @@ function resolveRobotRockAuthConfig(overrides) {
       "RobotRock auth is required. Set ROBOTROCK_API_KEY, ROBOTROCK_AGENT_SERVICE_TOKEN with tenant context, or pass auth when creating the client."
     );
   }
-  return { kind: "apiKey", apiKey };
+  return {
+    kind: "apiKey",
+    apiKey,
+    ...overrides?.actingUserId?.trim() ? { actingUserId: overrides.actingUserId.trim() } : {}
+  };
 }
 
 // src/chat-correlation.ts
@@ -1770,6 +2042,51 @@ function createChatsApi(config) {
           data
         );
       }
+    },
+    async uploadImage(input) {
+      const validation = agentChatUploadImageBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid image upload: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/images`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      const data = await parseResponseBody(response);
+      if (!response.ok) {
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to upload chat image"),
+          response.status,
+          data
+        );
+      }
+      const uploaded = data;
+      if (typeof uploaded.storageId !== "string" || typeof uploaded.url !== "string" || typeof uploaded.mediaType !== "string") {
+        throw new RobotRockError(
+          "Image upload returned an invalid response",
+          500,
+          data
+        );
+      }
+      return {
+        storageId: uploaded.storageId,
+        url: uploaded.url,
+        mediaType: uploaded.mediaType,
+        ...typeof uploaded.chatId === "string" ? { chatId: uploaded.chatId } : {},
+        ...typeof uploaded.publicTaskId === "string" ? { publicTaskId: uploaded.publicTaskId } : {},
+        ...typeof uploaded.filename === "string" ? { filename: uploaded.filename } : {},
+        ...typeof uploaded.description === "string" ? { description: uploaded.description } : {},
+        ...Array.isArray(uploaded.tags) ? {
+          tags: uploaded.tags.filter(
+            (tag) => typeof tag === "string"
+          )
+        } : {}
+      };
     }
   };
 }
@@ -1839,6 +2156,7 @@ var RobotRock = class {
     }
     this.auth = resolveRobotRockAuthConfig({
       ...apiKey ? { apiKey } : {},
+      ...config.actingUserId ? { actingUserId: config.actingUserId } : {},
       ...agentService ? { agentService } : {}
     });
     this.chatCorrelation = config.chatCorrelation;
@@ -2168,6 +2486,7 @@ function tryCreateBoundRobotRockClient(ctx) {
   if (apiKey) {
     return createClient({
       apiKey,
+      ...caller?.userId ? { actingUserId: caller.userId } : {},
       baseUrl: process.env.ROBOTROCK_BASE_URL?.trim(),
       chatCorrelation
     });
@@ -2597,6 +2916,9 @@ async function agentAdminFetch(config, path, init) {
 }
 function createAgentAdminApi(config) {
   return {
+    usage: {
+      get: () => agentAdminFetch(config, "/usage")
+    },
     members: {
       list: () => agentAdminFetch(config, "/members"),
       get: (memberRef) => agentAdminFetch(config, `/members/${encodeURIComponent(memberRef)}`),