robotrock 1.3.4 → 1.4.0

package/dist/eve/agent/index.js

@@ -551,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";
 
@@ -865,10 +1049,10 @@ function robotrockEveChannel(options) {
 }
 
 // src/schemas/index.ts
-import { z as z4 } from "zod";
+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) {
@@ -924,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;
@@ -1000,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"]
     });
@@ -1009,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 ?? [];
@@ -1022,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",
@@ -1032,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(),
@@ -1049,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.
@@ -1063,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 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 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 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;
@@ -1352,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"]
     });
@@ -1361,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 ?? [];
@@ -1374,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",
@@ -1384,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(),
@@ -1400,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.
@@ -1435,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";
@@ -1462,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
@@ -1583,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
@@ -1788,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"
+          )
+        } : {}
+      };
     }
   };
 }
@@ -1857,6 +2156,7 @@ var RobotRock = class {
     }
     this.auth = resolveRobotRockAuthConfig({
       ...apiKey ? { apiKey } : {},
+      ...config.actingUserId ? { actingUserId: config.actingUserId } : {},
       ...agentService ? { agentService } : {}
     });
     this.chatCorrelation = config.chatCorrelation;
@@ -2186,6 +2486,7 @@ function tryCreateBoundRobotRockClient(ctx) {
   if (apiKey) {
     return createClient({
       apiKey,
+      ...caller?.userId ? { actingUserId: caller.userId } : {},
       baseUrl: process.env.ROBOTROCK_BASE_URL?.trim(),
       chatCorrelation
     });
@@ -2615,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)}`),