robotrock 0.9.0 → 1.1.0

package/dist/eve/agent/index.js

@@ -0,0 +1,2322 @@
+// ../core/src/eve/user-context-jwt.ts
+import { createHmac, createSign, createVerify, randomBytes } from "crypto";
+var ROBOTROCK_USER_CONTEXT_ISSUER = "https://robotrock.io/eve-user-context";
+var ROBOTROCK_USER_CONTEXT_AUDIENCE = "eve";
+var ROBOTROCK_USER_CONTEXT_TTL_SECONDS = 5 * 60;
+function decodeJwtPart(part) {
+  return JSON.parse(Buffer.from(part, "base64url").toString("utf8"));
+}
+function readStringClaim(payload, key) {
+  const value = payload[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readGroupsClaim(payload) {
+  const value = payload.groups;
+  if (typeof value === "string" && value.length > 0) {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.filter(
+      (entry) => typeof entry === "string" && entry.length > 0
+    );
+  }
+  return [];
+}
+function parseTenantRoleClaim(value) {
+  if (value === "admin" || value === "member") {
+    return value;
+  }
+  return null;
+}
+function validateStandardClaims(payload, clockSkewSeconds) {
+  const now = Math.floor(Date.now() / 1e3);
+  const iss = readStringClaim(payload, "iss");
+  const aud = readStringClaim(payload, "aud");
+  const iat = payload.iat;
+  const exp = payload.exp;
+  if (iss !== ROBOTROCK_USER_CONTEXT_ISSUER) {
+    return false;
+  }
+  if (aud !== ROBOTROCK_USER_CONTEXT_AUDIENCE) {
+    return false;
+  }
+  if (typeof iat !== "number" || typeof exp !== "number") {
+    return false;
+  }
+  if (iat > now + clockSkewSeconds) {
+    return false;
+  }
+  if (exp < now - clockSkewSeconds) {
+    return false;
+  }
+  return true;
+}
+function verifyRobotRockPlatformUserContextJwt(args) {
+  const parts = args.token.split(".");
+  if (parts.length !== 3) {
+    return { ok: false };
+  }
+  const [encodedHeader, encodedPayload, encodedSignature] = parts;
+  if (!encodedHeader || !encodedPayload || !encodedSignature) {
+    return { ok: false };
+  }
+  let header;
+  let payload;
+  try {
+    header = decodeJwtPart(encodedHeader);
+    payload = decodeJwtPart(encodedPayload);
+  } catch {
+    return { ok: false };
+  }
+  if (header.alg !== "RS256") {
+    return { ok: false };
+  }
+  const verifier = createVerify("RSA-SHA256");
+  verifier.update(`${encodedHeader}.${encodedPayload}`);
+  verifier.end();
+  const signature = Buffer.from(encodedSignature, "base64url");
+  if (!verifier.verify(args.publicKeyPem, signature)) {
+    return { ok: false };
+  }
+  const clockSkewSeconds = args.clockSkewSeconds ?? 30;
+  if (!validateStandardClaims(payload, clockSkewSeconds)) {
+    return { ok: false };
+  }
+  const sub = readStringClaim(payload, "sub");
+  const email = readStringClaim(payload, "email");
+  const name = readStringClaim(payload, "name");
+  const tenantSlug = readStringClaim(payload, "tenantSlug");
+  const connectionId = readStringClaim(payload, "connectionId");
+  const role = parseTenantRoleClaim(readStringClaim(payload, "role"));
+  const workosUserId = readStringClaim(payload, "workosUserId");
+  const iat = payload.iat;
+  const exp = payload.exp;
+  if (!sub || !email || !name || !tenantSlug || !connectionId || !role || typeof iat !== "number" || typeof exp !== "number") {
+    return { ok: false };
+  }
+  return {
+    ok: true,
+    claims: {
+      iss: ROBOTROCK_USER_CONTEXT_ISSUER,
+      aud: ROBOTROCK_USER_CONTEXT_AUDIENCE,
+      sub,
+      email,
+      name,
+      tenantSlug,
+      connectionId,
+      role,
+      groups: readGroupsClaim(payload),
+      ...workosUserId ? { workosUserId } : {},
+      iat,
+      exp
+    }
+  };
+}
+
+// ../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";
+
+// src/eve/input-request.ts
+var EVE_INPUT_SUBMIT_ACTION_ID = "submit";
+var EVE_INPUT_OTHER_CHOICE_ID = "__other__";
+var EVE_INPUT_OTHER_CHOICE_LABEL = "Type your own answer";
+var CONFIRMATION_DEFAULT_OPTIONS = [
+  { id: "approve", label: "Approve", style: "primary" },
+  { id: "deny", label: "Deny", style: "danger" }
+];
+var SELECT_PER_OPTION_THRESHOLD = 6;
+function resolveEveInputDisplay(request, toolName) {
+  if (request.display) {
+    return request.display;
+  }
+  if (toolName === "ask_question") {
+    return request.options && request.options.length > 0 ? "select" : "text";
+  }
+  if (request.options && request.options.length > 0) {
+    return "select";
+  }
+  return "confirmation";
+}
+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 } : {}
+  }));
+}
+function textSubmitAction(prompt) {
+  return {
+    id: EVE_INPUT_SUBMIT_ACTION_ID,
+    title: "Submit",
+    schema: {
+      type: "object",
+      required: ["answer"],
+      properties: {
+        answer: {
+          type: "string",
+          title: "Your answer"
+        }
+      }
+    },
+    ui: {
+      answer: {
+        "ui:title": prompt.trim() || "Your answer",
+        "ui:widget": "textarea"
+      }
+    }
+  };
+}
+function selectPerOptionActions(options) {
+  return options.map((option) => ({
+    id: option.id,
+    title: option.label,
+    ...option.description ? { description: 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);
+  if (allowFreeform) {
+    enumValues.push(EVE_INPUT_OTHER_CHOICE_ID);
+    enumNames.push(EVE_INPUT_OTHER_CHOICE_LABEL);
+  }
+  const properties = {
+    choice: {
+      type: "string",
+      title: "Choose one",
+      enum: enumValues
+    }
+  };
+  if (allowFreeform) {
+    properties.other = {
+      type: "string",
+      title: "Your answer"
+    };
+  }
+  const schema = {
+    type: "object",
+    required: ["choice"],
+    properties
+  };
+  if (allowFreeform) {
+    schema.allOf = [
+      {
+        if: {
+          properties: {
+            choice: { const: EVE_INPUT_OTHER_CHOICE_ID }
+          },
+          required: ["choice"]
+        },
+        then: {
+          required: ["other"],
+          properties: {
+            other: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        }
+      }
+    ];
+  }
+  const ui = {
+    choice: {
+      "ui:widget": "radio",
+      "ui:enumNames": enumNames
+    }
+  };
+  if (allowFreeform) {
+    ui.other = {
+      "ui:placeholder": "Enter your answer"
+    };
+  }
+  return {
+    id: EVE_INPUT_SUBMIT_ACTION_ID,
+    title: "Submit",
+    schema,
+    ui
+  };
+}
+function eveInputRequestToActions(request, options) {
+  const display = resolveEveInputDisplay(request, options?.toolName);
+  switch (display) {
+    case "confirmation":
+      return confirmationActions(request);
+    case "text":
+      return [textSubmitAction(request.prompt)];
+    case "select": {
+      const selectOptions = request.options ?? [];
+      if (selectOptions.length === 0) {
+        return [textSubmitAction(request.prompt)];
+      }
+      if (selectOptions.length <= SELECT_PER_OPTION_THRESHOLD && request.allowFreeform !== true) {
+        return selectPerOptionActions(selectOptions);
+      }
+      return [selectFormAction(request)];
+    }
+  }
+}
+
+// src/eve/input-audit.ts
+function matchOptionByText(text, options) {
+  const normalized = text.trim().toLowerCase();
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  const byId = options.find((option) => option.id.toLowerCase() === normalized);
+  if (byId) {
+    return byId;
+  }
+  const byLabel = options.find((option) => option.label.toLowerCase() === normalized);
+  if (byLabel) {
+    return byLabel;
+  }
+  const index = Number(normalized);
+  if (Number.isInteger(index) && index > 0 && index <= options.length) {
+    return options[index - 1];
+  }
+  return void 0;
+}
+function resolveEveFreeformTextToInputResponse(request, text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const options = request.options ?? [];
+  if (options.length > 0) {
+    const matched = matchOptionByText(trimmed, options);
+    if (matched) {
+      return { requestId: request.requestId, optionId: matched.id };
+    }
+  }
+  if (request.allowFreeform === true || options.length === 0) {
+    return { requestId: request.requestId, text: trimmed };
+  }
+  return void 0;
+}
+function isEveApprovalInputRequest(request) {
+  const options = request.options ?? [];
+  return options.length === 2 && options[0]?.id === "approve" && options[1]?.id === "deny";
+}
+function eveInputResponseToActionSubmission(request, response, options) {
+  const display = resolveEveInputDisplay(request, options?.toolName);
+  const actions = eveInputRequestToActions(request, options);
+  if (response.optionId) {
+    const action = actions.find((entry) => entry.id === response.optionId);
+    if (action) {
+      return {
+        actionId: response.optionId,
+        actionTitle: action.title,
+        formData: {}
+      };
+    }
+    const option = request.options?.find((entry) => entry.id === response.optionId);
+    if (option) {
+      return {
+        actionId: response.optionId,
+        actionTitle: option.label,
+        formData: {}
+      };
+    }
+    return {
+      actionId: response.optionId,
+      actionTitle: response.optionId,
+      formData: {}
+    };
+  }
+  const text = response.text?.trim();
+  if (text) {
+    if (display === "text") {
+      return {
+        actionId: EVE_INPUT_SUBMIT_ACTION_ID,
+        actionTitle: text,
+        formData: { answer: text }
+      };
+    }
+    if (display === "select") {
+      const option = request.options?.find((entry) => entry.id === text);
+      if (option) {
+        return {
+          actionId: EVE_INPUT_SUBMIT_ACTION_ID,
+          actionTitle: option.label,
+          formData: { choice: option.id }
+        };
+      }
+      return {
+        actionId: EVE_INPUT_SUBMIT_ACTION_ID,
+        actionTitle: text,
+        formData: { choice: text }
+      };
+    }
+    return {
+      actionId: EVE_INPUT_SUBMIT_ACTION_ID,
+      actionTitle: text,
+      formData: { answer: text }
+    };
+  }
+  return {
+    actionId: EVE_INPUT_SUBMIT_ACTION_ID,
+    actionTitle: "Responded",
+    formData: {}
+  };
+}
+function buildEveInputAuditSubmissionData(context, formData) {
+  return {
+    toolCallId: context.toolCallId,
+    ...context.toolName ? { toolName: context.toolName } : {},
+    ...context.requestId ? { requestId: context.requestId } : {},
+    ...context.display ? { display: context.display } : {},
+    ...context.toolInput !== void 0 ? { toolInput: context.toolInput } : {},
+    ...formData
+  };
+}
+function parseEveAskQuestionToolOutput(output) {
+  if (output == null || typeof output !== "object") {
+    return null;
+  }
+  const record = output;
+  const value = record.type === "json" && record.value != null && typeof record.value === "object" ? record.value : record;
+  const optionId = typeof value.optionId === "string" ? value.optionId : void 0;
+  const text = typeof value.text === "string" ? value.text : void 0;
+  if (!optionId && !text) {
+    return null;
+  }
+  return { ...optionId ? { optionId } : {}, ...text ? { text } : {} };
+}
+
+// src/eve/index.ts
+var ROBOTROCK_READY_HOOK_SLUG = "robotrock-ready";
+
+// src/eve/agent/constants.ts
+var ROBOTROCK_USER_CONTEXT_HEADER = "x-robotrock-user-token";
+
+// src/eve/agent/attributes.ts
+function readStringAttribute(attributes, key) {
+  const value = attributes?.[key];
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  if (Array.isArray(value) && typeof value[0] === "string" && value[0].length > 0) {
+    return value[0];
+  }
+  return void 0;
+}
+function readStringArrayAttribute(attributes, key) {
+  const value = attributes?.[key];
+  if (typeof value === "string" && value.length > 0) {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.filter(
+      (entry) => typeof entry === "string" && entry.length > 0
+    );
+  }
+  return [];
+}
+function parseTenantRole(value) {
+  if (value === "admin" || value === "member") {
+    return value;
+  }
+  return null;
+}
+
+// src/eve/agent/tenant.ts
+function tryResolveTenantCaller(ctx) {
+  const caller = ctx.session.auth.initiator ?? ctx.session.auth.current;
+  if (caller?.principalType !== "user") {
+    return null;
+  }
+  const email = readStringAttribute(caller.attributes, "email");
+  const name = readStringAttribute(caller.attributes, "name");
+  const tenantSlug = readStringAttribute(caller.attributes, "tenantSlug") ?? readStringAttribute(caller.attributes, "tenantId");
+  const role = parseTenantRole(readStringAttribute(caller.attributes, "role"));
+  if (!email || !tenantSlug || !caller.principalId || !role) {
+    return null;
+  }
+  const workosUserId = readStringAttribute(caller.attributes, "workosUserId");
+  const connectionId = readStringAttribute(caller.attributes, "connectionId");
+  const groups = readStringArrayAttribute(caller.attributes, "groups");
+  return {
+    userId: caller.principalId,
+    email,
+    name: name ?? email.split("@")[0] ?? email,
+    tenantSlug,
+    ...connectionId ? { connectionId } : {},
+    role,
+    isAdmin: role === "admin",
+    groups,
+    ...workosUserId ? { workosUserId } : {}
+  };
+}
+function requireTenantCaller(ctx) {
+  const caller = tryResolveTenantCaller(ctx);
+  if (!caller) {
+    throw new Error("An authenticated RobotRock tenant user is required.");
+  }
+  return caller;
+}
+function isAdminCaller(ctx) {
+  return tryResolveTenantCaller(ctx)?.isAdmin === true;
+}
+function requireAdminCaller(ctx) {
+  const caller = requireTenantCaller(ctx);
+  if (!caller.isAdmin) {
+    throw new Error("Tenant admin access is required.");
+  }
+  return caller;
+}
+
+// src/eve/agent/auth.ts
+import {
+  verifyJwtHmac,
+  extractBearerToken
+} from "eve/channels/auth";
+
+// src/eve/agent/platform-public-key.ts
+var cachedPublicKeyPem;
+async function resolvePlatformUserContextPublicKeyPem() {
+  const envOverride = process.env.ROBOTROCK_USER_CONTEXT_PUBLIC_KEY?.trim();
+  if (envOverride) {
+    return envOverride;
+  }
+  if (cachedPublicKeyPem !== void 0) {
+    return cachedPublicKeyPem;
+  }
+  try {
+    const response = await fetch(ROBOTROCK_PLATFORM_USER_CONTEXT_PUBLIC_KEY_URL, {
+      headers: { Accept: "text/plain" }
+    });
+    if (!response.ok) {
+      cachedPublicKeyPem = null;
+      return null;
+    }
+    const pem = (await response.text()).trim();
+    cachedPublicKeyPem = pem.length > 0 ? pem : null;
+    return cachedPublicKeyPem;
+  } catch {
+    cachedPublicKeyPem = null;
+    return null;
+  }
+}
+
+// src/eve/agent/auth.ts
+function mapVerifiedClaimsToSessionAuth(claims) {
+  return {
+    authenticator: "robotrock",
+    principalId: claims.sub,
+    principalType: "user",
+    subject: claims.sub,
+    issuer: ROBOTROCK_USER_CONTEXT_ISSUER,
+    attributes: {
+      email: claims.email,
+      name: claims.name,
+      tenantSlug: claims.tenantSlug,
+      tenantId: claims.tenantSlug,
+      role: claims.role,
+      groups: claims.groups,
+      ...claims.connectionId ? { connectionId: claims.connectionId } : {},
+      ...claims.workosUserId ? { workosUserId: claims.workosUserId } : {}
+    }
+  };
+}
+function robotrockUserContextAuth(options) {
+  return async (request) => {
+    const token = extractBearerToken(
+      request.headers.get(ROBOTROCK_USER_CONTEXT_HEADER)
+    );
+    if (!token) {
+      return null;
+    }
+    let publicKeyPem = null;
+    if (typeof options?.publicKeyPem === "function") {
+      publicKeyPem = await options.publicKeyPem();
+    } else if (options?.publicKeyPem) {
+      publicKeyPem = options.publicKeyPem;
+    } else {
+      publicKeyPem = await resolvePlatformUserContextPublicKeyPem();
+    }
+    if (publicKeyPem) {
+      const platformResult = verifyRobotRockPlatformUserContextJwt({
+        token,
+        publicKeyPem
+      });
+      if (platformResult.ok) {
+        return mapVerifiedClaimsToSessionAuth(platformResult.claims);
+      }
+    }
+    const secret = options?.hmacSecret?.trim() ?? process.env.ROBOTROCK_USER_CONTEXT_SECRET?.trim();
+    if (!secret) {
+      return null;
+    }
+    const result = await verifyJwtHmac(token, {
+      algorithm: "HS256",
+      issuer: ROBOTROCK_USER_CONTEXT_ISSUER,
+      audiences: [ROBOTROCK_USER_CONTEXT_AUDIENCE],
+      secret
+    });
+    if (!result.ok) {
+      return null;
+    }
+    const email = readStringAttribute(result.sessionAuth.attributes, "email");
+    const name = readStringAttribute(result.sessionAuth.attributes, "name");
+    const tenantSlug = readStringAttribute(
+      result.sessionAuth.attributes,
+      "tenantSlug"
+    );
+    const connectionId = readStringAttribute(
+      result.sessionAuth.attributes,
+      "connectionId"
+    );
+    const role = parseTenantRole(
+      readStringAttribute(result.sessionAuth.attributes, "role")
+    );
+    const groups = readStringArrayAttribute(result.sessionAuth.attributes, "groups");
+    const subject = result.sessionAuth.subject;
+    if (!email || !tenantSlug || !subject || !role) {
+      return null;
+    }
+    const workosUserId = readStringAttribute(
+      result.sessionAuth.attributes,
+      "workosUserId"
+    );
+    return mapVerifiedClaimsToSessionAuth({
+      sub: subject,
+      email,
+      name: name ?? email.split("@")[0] ?? email,
+      tenantSlug,
+      connectionId,
+      role,
+      groups,
+      workosUserId
+    });
+  };
+}
+function robotrockAgentServiceAuth() {
+  return async (request) => {
+    const expected = process.env.ROBOTROCK_AGENT_SERVICE_TOKEN?.trim();
+    if (!expected) {
+      return null;
+    }
+    const bearer = extractBearerToken(request.headers.get("authorization"));
+    if (!bearer || bearer !== expected) {
+      return null;
+    }
+    return {
+      authenticator: "robotrock-agent-service",
+      principalId: "robotrock:platform",
+      principalType: "runtime",
+      attributes: {}
+    };
+  };
+}
+function eveSelfServiceAuth() {
+  return async (request) => {
+    const expected = process.env.EVE_SELF_AUTH_TOKEN?.trim();
+    if (!expected) {
+      return null;
+    }
+    const bearer = extractBearerToken(request.headers.get("authorization"));
+    if (bearer !== expected) {
+      return null;
+    }
+    return {
+      authenticator: "eve-self",
+      principalId: "eve:runtime",
+      principalType: "runtime",
+      attributes: {}
+    };
+  };
+}
+
+// src/eve/agent/channel.ts
+import { eveChannel } from "eve/channels/eve";
+import { localDev, vercelOidc } from "eve/channels/auth";
+function shouldEnableLocalDev(explicit) {
+  if (explicit !== void 0) {
+    return explicit;
+  }
+  return process.env.NODE_ENV !== "production";
+}
+function robotrockEveChannel(options) {
+  const auth = [];
+  const includeRobotrock = options?.robotrock !== false;
+  if (includeRobotrock) {
+    auth.push(robotrockUserContextAuth(options?.userContextAuth));
+  }
+  if (options?.auth?.length) {
+    auth.push(...options.auth);
+  }
+  if (includeRobotrock) {
+    auth.push(robotrockAgentServiceAuth());
+    auth.push(eveSelfServiceAuth());
+  }
+  if (options?.vercelOidc !== false) {
+    auth.push(vercelOidc(options?.vercelOidc ?? void 0));
+  }
+  if (shouldEnableLocalDev(options?.localDev)) {
+    auth.push(localDev());
+  }
+  return eveChannel({ auth });
+}
+
+// src/schemas/index.ts
+import { z as z2 } 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";
+
+// ../core/src/schemas/task.ts
+import { z } from "zod";
+
+// ../core/src/schemas/context-urls.ts
+function resolveLinkUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://") ? value : `https://${value}`;
+}
+function widgetType(ui, field) {
+  const fieldUi = ui?.[field];
+  if (typeof fieldUi !== "object" || fieldUi === null) {
+    return void 0;
+  }
+  const widget = fieldUi["ui:widget"];
+  return typeof widget === "string" ? widget : void 0;
+}
+function validateUrlValue(value, widget) {
+  if (widget === "image" || widget === "link") {
+    if (typeof value !== "string") {
+      return PUBLIC_HTTP_URL_ERROR;
+    }
+    const url = widget === "link" ? resolveLinkUrl(value) : value;
+    if (!isPublicHttpUrl(url)) {
+      return PUBLIC_HTTP_URL_ERROR;
+    }
+    return null;
+  }
+  if (widget === "attachments" && Array.isArray(value)) {
+    for (const item of value) {
+      if (typeof item !== "object" || item === null) {
+        continue;
+      }
+      const url = item.url;
+      if (typeof url === "string" && !isPublicHttpUrl(resolveLinkUrl(url))) {
+        return PUBLIC_HTTP_URL_ERROR;
+      }
+    }
+  }
+  return null;
+}
+function validateContextPublicUrls(context) {
+  if (!context?.data) {
+    return null;
+  }
+  for (const [field, value] of Object.entries(context.data)) {
+    const widget = widgetType(context.ui, field);
+    if (!widget) {
+      continue;
+    }
+    const error = validateUrlValue(value, widget);
+    if (error) {
+      return `context.data.${field}: ${error}`;
+    }
+  }
+  return null;
+}
+
+// ../core/src/schemas/task.ts
+var safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {
+  message: PUBLIC_HTTP_URL_ERROR
+});
+var handlerUrlSchema = z.string().refine((url) => isAllowedHandlerUrl(url), {
+  message: HANDLER_URL_ERROR
+});
+var jsonSchema7Schema = z.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, {
+  message: "Must be a valid UiSchema object"
+});
+var webhookHandlerSchema = z.object({
+  type: z.literal("webhook"),
+  url: handlerUrlSchema,
+  headers: z.record(z.string(), z.string())
+});
+var triggerHandlerSchema = webhookHandlerSchema.extend({
+  type: z.literal("trigger"),
+  tokenId: z.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(),
+  schema: jsonSchema7Schema.optional(),
+  ui: uiSchemaSchema.optional(),
+  data: z.record(z.string(), z.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()
+}).passthrough();
+var contextUiSchema = z.record(z.string(), uiFieldSchemaSchema).optional();
+var contextDataSchema = z.object({
+  data: z.record(z.string(), z.unknown()),
+  ui: contextUiSchema
+}).optional();
+var TASK_CONTEXT_FORMAT_VERSION = 2;
+var taskContextObjectBaseSchema = z.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(),
+  context: contextDataSchema,
+  /** Task context wire format version. @default 2 */
+  contextVersion: z.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")
+});
+function normalizeTaskContextVersion(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION
+  };
+}
+var taskContextObjectSchema = taskContextObjectBaseSchema.transform(
+  normalizeTaskContextVersion
+);
+function refineContextPublicUrls(data, ctx) {
+  const error = validateContextPublicUrls(data.context);
+  if (error) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: error,
+      path: ["context"]
+    });
+  }
+}
+var taskContextSchema = taskContextObjectSchema.superRefine(
+  refineContextPublicUrls
+);
+var assignToSchema = z.object({
+  users: z.array(z.string().email()).optional(),
+  groups: z.array(z.string().min(1)).optional()
+}).refine(
+  (data) => {
+    const groups = data.groups ?? [];
+    if (groups.includes("all") && groups.length > 1) {
+      return false;
+    }
+    return true;
+  },
+  { message: 'Cannot combine "all" with other group slugs' }
+);
+var threadUpdateMessageSchema = z.string().min(1).max(500);
+var threadUpdateStatuses = [
+  "info",
+  "queued",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+var threadUpdateStatusSchema = z.enum(threadUpdateStatuses);
+var threadUpdateInputSchema = z.object({
+  message: threadUpdateMessageSchema,
+  status: threadUpdateStatusSchema.optional()
+});
+var taskPriorities = ["low", "normal", "high", "urgent"];
+var taskPrioritySchema = z.enum(taskPriorities);
+var agentTelemetrySchema = z.object({
+  /** Agent or app version (semver, git SHA, deploy tag — caller-defined). */
+  version: z.string().min(1)
+});
+var createTaskBodySchema = taskContextObjectBaseSchema.extend({
+  assignTo: assignToSchema.optional(),
+  /**
+   * 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(),
+  /**
+   * Optional thread priority. When set, applies to the whole thread and
+   * overwrites any previous priority. Omit on later tasks to leave unchanged.
+   */
+  priority: taskPrioritySchema.optional(),
+  /**
+   * Optional initial status update logged against the task's thread. Shows in
+   * the inbox status bar and the thread update log.
+   */
+  update: threadUpdateInputSchema.optional(),
+  /** Agent release version — not shown in inbox UI. */
+  agent: agentTelemetrySchema.optional()
+}).transform(normalizeTaskContextVersion).superRefine(refineContextPublicUrls);
+var agentChatSeedActionSchema = z.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(),
+  /** JSON Schema object for the form fields. */
+  schema: z.record(z.string(), z.unknown()).optional(),
+  /** RJSF ui schema overrides (ui:widget, ui:enumNames, etc.). */
+  ui: z.record(z.string(), z.unknown()).optional(),
+  /** Optional default field values. */
+  data: z.record(z.string(), z.unknown()).optional()
+});
+var agentChatSeedMessageSchema = z.object({
+  role: z.enum(["user", "assistant"]),
+  text: z.string().min(1),
+  /** Optional display-name override for the message sender. */
+  senderName: z.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(),
+    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 createAgentChatBodySchema = z.object({
+  /** Agent id (eve agent name). Required unless `parentChatId` is set. */
+  agentIdentifier: z.string().min(1).optional(),
+  /** Inherit tenant/connection/agent from an existing chat (agent-spawned chats). */
+  parentChatId: z.string().min(1).optional(),
+  /** Convex tenantEveConnections id; resolved from the tenant when omitted. */
+  eveConnectionId: z.string().min(1).optional(),
+  /** Source application id; groups the chat under an inbox section. */
+  app: z.string().min(1).optional(),
+  assignTo: assignToSchema.optional(),
+  title: z.string().min(1),
+  messages: z.array(agentChatSeedMessageSchema).default([]),
+  /** Provenance label stored on the session ("cron" | "agent" | ...). */
+  source: z.string().min(1).optional()
+}).refine((data) => Boolean(data.agentIdentifier || data.parentChatId), {
+  message: "Provide either agentIdentifier or parentChatId"
+});
+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(),
+  /** Eve input request id — used to merge staged HITL metadata. */
+  requestId: z.string().optional(),
+  /** Eve tool call id — fallback lookup for staged HITL metadata. */
+  toolCallId: z.string().optional()
+});
+var eveHitlStagedOptionSchema = z.object({
+  id: z.string(),
+  label: z.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 agentChatLinkTaskBodySchema = z.object({
+  eveSessionId: z.string().min(1),
+  publicTaskId: z.string().min(1),
+  toolCallId: z.string().min(1)
+});
+
+// src/schemas/index.ts
+var handlerUrlSchema2 = z2.string().refine((url) => isAllowedHandlerUrl(url), {
+  message: HANDLER_URL_ERROR
+});
+var jsonSchema7Schema2 = z2.custom(
+  (val) => typeof val === "object" && val !== null,
+  { message: "Must be a valid JSON Schema object" }
+);
+var uiSchemaSchema2 = z2.custom((val) => typeof val === "object" && val !== null, {
+  message: "Must be a valid UiSchema object"
+});
+var webhookHandlerSchema2 = z2.object({
+  type: z2.literal("webhook"),
+  url: handlerUrlSchema2,
+  headers: z2.record(z2.string(), z2.string())
+});
+var triggerHandlerSchema2 = webhookHandlerSchema2.extend({
+  type: z2.literal("trigger"),
+  tokenId: z2.string().min(1)
+});
+var handlerSchema2 = z2.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
+var taskActionInputSchema2 = z2.object({
+  id: z2.string().min(1),
+  title: z2.string().min(1),
+  description: z2.string().optional(),
+  schema: jsonSchema7Schema2.optional(),
+  ui: uiSchemaSchema2.optional(),
+  data: z2.record(z2.string(), z2.unknown()).optional()
+});
+var taskActionSchema2 = taskActionInputSchema2.extend({
+  handlers: z2.array(handlerSchema2).min(1).optional()
+});
+var uiFieldSchemaSchema2 = 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(), uiFieldSchemaSchema2)).optional()
+}).passthrough();
+var contextUiSchema2 = z2.record(z2.string(), uiFieldSchemaSchema2).optional();
+var contextDataSchema2 = z2.object({
+  data: z2.record(z2.string(), z2.unknown()),
+  ui: contextUiSchema2
+}).optional();
+var TASK_CONTEXT_FORMAT_VERSION2 = 2;
+var taskContextObjectBaseSchema2 = z2.object({
+  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: contextDataSchema2,
+  contextVersion: z2.literal(2).optional(),
+  /** @deprecated Use `contextVersion`. Accepted on ingest only. */
+  version: z2.literal(2).optional(),
+  actions: z2.array(taskActionSchema2).min(1, "At least one action is required")
+});
+function normalizeTaskContextVersion2(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION2
+  };
+}
+var taskContextObjectSchema2 = taskContextObjectBaseSchema2.transform(
+  normalizeTaskContextVersion2
+);
+function refineContextPublicUrls2(data, ctx) {
+  const error = validateContextPublicUrls(data.context);
+  if (error) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: error,
+      path: ["context"]
+    });
+  }
+}
+var taskContextSchema2 = taskContextObjectSchema2.superRefine(
+  refineContextPublicUrls2
+);
+var assignToSchema2 = z2.object({
+  users: z2.array(z2.string().email()).optional(),
+  groups: z2.array(z2.string().min(1)).optional()
+}).refine(
+  (data) => {
+    const groups = data.groups ?? [];
+    if (groups.includes("all") && groups.length > 1) {
+      return false;
+    }
+    return true;
+  },
+  { message: 'Cannot combine "all" with other group slugs' }
+);
+var threadUpdateMessageSchema2 = z2.string().min(1).max(500);
+var threadUpdateStatuses2 = [
+  "info",
+  "queued",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+var threadUpdateStatusSchema2 = z2.enum(threadUpdateStatuses2);
+var threadUpdateInputSchema2 = z2.object({
+  message: threadUpdateMessageSchema2,
+  status: threadUpdateStatusSchema2.optional()
+});
+var taskPriorities2 = ["low", "normal", "high", "urgent"];
+var taskPrioritySchema2 = z2.enum(taskPriorities2);
+var agentTelemetrySchema2 = z2.object({
+  version: z2.string().min(1)
+});
+var createTaskBodySchema2 = taskContextObjectBaseSchema2.extend({
+  assignTo: assignToSchema2.optional(),
+  /**
+   * 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: 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.
+   */
+  priority: taskPrioritySchema2.optional(),
+  /**
+   * Optional initial status update logged against the task's thread. Shows in
+   * the inbox status bar and the thread update log.
+   */
+  update: threadUpdateInputSchema2.optional(),
+  agent: agentTelemetrySchema2.optional()
+}).transform(normalizeTaskContextVersion2).superRefine(refineContextPublicUrls2);
+var threadUpdateBodySchema = threadUpdateInputSchema2;
+
+// src/approval-result.ts
+var TaskTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TaskTimeoutError";
+  }
+};
+var TaskExpiredError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TaskExpiredError";
+  }
+};
+function toDiscriminatedApprovalResult(actions, task) {
+  void actions;
+  if (!task.handled) {
+    throw new Error("Task has no handled result");
+  }
+  return {
+    actionId: task.handled.action.id,
+    data: task.handled.action.data,
+    handledBy: task.handled.handledBy,
+    handledAt: new Date(task.handledAt ?? Date.now()),
+    taskId: task.id
+  };
+}
+
+// src/http.ts
+var RobotRockError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "RobotRockError";
+  }
+};
+async function parseResponseBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  const bodyText = await response.text();
+  if (!bodyText) {
+    return null;
+  }
+  if (contentType.toLowerCase().includes("application/json")) {
+    try {
+      return JSON.parse(bodyText);
+    } catch {
+    }
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    return bodyText;
+  }
+}
+function getErrorMessage(data, fallback) {
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    const record = data;
+    const maybeMessage = record.message;
+    const maybeHint = record.hint;
+    if (typeof maybeMessage === "string" && maybeMessage.trim()) {
+      if (typeof maybeHint === "string" && maybeHint.trim()) {
+        return `${maybeMessage.trim()} ${maybeHint.trim()}`;
+      }
+      return maybeMessage;
+    }
+  }
+  if (typeof data === "string" && data.trim()) {
+    const compact = data.replace(/\s+/g, " ").trim();
+    const snippet = compact.length > 180 ? `${compact.slice(0, 180)}...` : compact;
+    return `${fallback}. Server returned non-JSON response: ${snippet}`;
+  }
+  return fallback;
+}
+
+// ../core/src/handler-retry.ts
+var HANDLER_RETRY_DELAYS_MS = [
+  6e4,
+  // 1m
+  3e5,
+  // 5m
+  18e5,
+  // 30m
+  36e5,
+  // 1h
+  216e5,
+  // 6h
+  864e5,
+  // 24h
+  1728e5
+  // 48h
+];
+var HANDLER_MAX_ATTEMPTS = HANDLER_RETRY_DELAYS_MS.length + 1;
+
+// ../core/src/attribution/index.ts
+import { z as z3 } from "zod";
+
+// ../core/src/app-url.ts
+var PRODUCTION_APP_URL = "https://app.robotrock.io";
+var PRODUCTION_API_URL = "https://api.robotrock.io/v1";
+var DEV_API_URL = "http://localhost:4001/v1";
+var APP_SIGNUP_URL = `${PRODUCTION_APP_URL}/sign-up`;
+function normalizeRobotRockApiBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (trimmed.endsWith("/v1")) {
+    return trimmed;
+  }
+  return `${trimmed}/v1`;
+}
+function getRobotRockApiBaseUrl() {
+  const explicit = process.env.ROBOTROCK_BASE_URL?.trim() || process.env.ROBOTROCK_API_URL?.trim();
+  if (explicit) {
+    return normalizeRobotRockApiBaseUrl(explicit);
+  }
+  if (process.env.NODE_ENV === "production") {
+    return PRODUCTION_API_URL;
+  }
+  return DEV_API_URL;
+}
+
+// ../core/src/attribution/index.ts
+var ATTRIBUTION_COOKIE_MAX_AGE = 60 * 60 * 24 * 90;
+var attributionSchema = z3.object({
+  utmSource: z3.string().optional(),
+  utmMedium: z3.string().optional(),
+  utmCampaign: z3.string().optional(),
+  utmContent: z3.string().optional(),
+  utmTerm: z3.string().optional(),
+  gclid: z3.string().optional(),
+  landingUrl: z3.string().optional(),
+  referrer: z3.string().optional(),
+  capturedAt: z3.number()
+});
+
+// src/auth-headers.ts
+function buildRobotRockAuthHeaders(auth) {
+  if (auth.kind === "apiKey") {
+    return {
+      "X-Api-Key": auth.apiKey
+    };
+  }
+  return {
+    Authorization: `Bearer ${auth.token}`,
+    "X-RobotRock-Tenant-Slug": auth.tenantSlug,
+    "X-RobotRock-Connection-Id": auth.connectionId
+  };
+}
+function resolveRobotRockAuthConfig(overrides) {
+  if (overrides?.agentService) {
+    return {
+      kind: "agentService",
+      ...overrides.agentService
+    };
+  }
+  const apiKey = overrides?.apiKey ?? process.env.ROBOTROCK_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "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 };
+}
+
+// src/chats.ts
+function createChatsApi(config) {
+  const headers = () => ({
+    "Content-Type": "application/json",
+    ...buildRobotRockAuthHeaders(config.auth)
+  });
+  return {
+    async create(input) {
+      const bodyPayload = {
+        ...input,
+        app: input.app ?? config.app,
+        messages: input.messages ?? []
+      };
+      const validation = createAgentChatBodySchema.safeParse(bodyPayload);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid chat: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      const data = await parseResponseBody(response);
+      if (!response.ok) {
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to create chat"),
+          response.status,
+          data
+        );
+      }
+      const result = data;
+      return { tenantSlug: result.tenantSlug, chats: result.chats };
+    },
+    async close(chatId, options) {
+      if (!chatId) {
+        throw new RobotRockError("chatId is required to close a chat", 400);
+      }
+      const response = await fetch(
+        `${config.baseUrl}/agent-chats/${encodeURIComponent(chatId)}/close`,
+        {
+          method: "POST",
+          headers: headers(),
+          body: JSON.stringify({ reason: options?.reason })
+        }
+      );
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to close chat"),
+          response.status,
+          data
+        );
+      }
+    },
+    async stageHitlRequests(input) {
+      const validation = agentChatStageHitlBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid stage HITL input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/stage-hitl`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to stage chat HITL requests"),
+          response.status,
+          data
+        );
+      }
+    },
+    async getStagedHitlRequests(eveSessionId) {
+      const trimmed = eveSessionId.trim();
+      if (!trimmed) {
+        throw new RobotRockError("eveSessionId is required", 400);
+      }
+      const url = new URL(`${config.baseUrl}/agent-chats/staged-hitl`);
+      url.searchParams.set("eveSessionId", trimmed);
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: headers()
+      });
+      const data = await parseResponseBody(response);
+      if (!response.ok) {
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to fetch staged chat HITL requests"),
+          response.status,
+          data
+        );
+      }
+      const requests = data.requests;
+      return Array.isArray(requests) ? requests : [];
+    },
+    async logInputSubmission(input) {
+      const validation = agentChatAuditInputBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid audit input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/audit-input`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to log chat input submission"),
+          response.status,
+          data
+        );
+      }
+    },
+    async linkTask(input) {
+      const validation = agentChatLinkTaskBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid link task input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/link-task`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to link inbox task to chat"),
+          response.status,
+          data
+        );
+      }
+    }
+  };
+}
+
+// src/client.ts
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveAgentVersionFromEnv() {
+  const fromEnv = process.env.AGENT_VERSION?.trim() || process.env.ROBOTROCK_AGENT_VERSION?.trim();
+  return fromEnv || void 0;
+}
+function parseValidUntilMs(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    return Number.isNaN(ms) ? void 0 : ms;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function serializeValidUntil(value) {
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    if (Number.isNaN(ms)) {
+      throw new RobotRockError("Invalid validUntil: Date is invalid", 400);
+    }
+    return value.toISOString();
+  }
+  if (typeof value === "string" && !Number.isNaN(Date.parse(value))) {
+    return new Date(value).toISOString();
+  }
+  throw new RobotRockError("Invalid validUntil: expected a Date or parseable date string", 400);
+}
+var RobotRock = class {
+  auth;
+  baseUrl;
+  app;
+  agentVersion;
+  contextVersion;
+  webhook;
+  polling;
+  /** Task CRUD: `create`, `get`, `cancel`, `sendUpdate`. */
+  tasks;
+  /** Chat CRUD: `create`, `close`. */
+  chats;
+  constructor(config) {
+    if (config.webhook && config.polling) {
+      throw new Error(
+        "RobotRock client cannot configure both webhook and polling. Use webhook for callbacks or polling to block until handled."
+      );
+    }
+    const apiKey = config.apiKey ?? process.env.ROBOTROCK_API_KEY;
+    const agentService = config.agentService;
+    if (apiKey && agentService) {
+      throw new Error(
+        "RobotRock client cannot configure both apiKey and agentService."
+      );
+    }
+    this.auth = resolveRobotRockAuthConfig({
+      ...apiKey ? { apiKey } : {},
+      ...agentService ? { agentService } : {}
+    });
+    this.baseUrl = config.baseUrl ?? getRobotRockApiBaseUrl();
+    this.app = config.app;
+    this.agentVersion = config.version ?? resolveAgentVersionFromEnv();
+    this.contextVersion = config.advanced?.contextVersion ?? TASK_CONTEXT_FORMAT_VERSION2;
+    this.webhook = config.webhook;
+    this.polling = config.polling ?? {};
+    this.tasks = {
+      create: (task) => this.createTaskRequest(task),
+      get: (taskId) => this.getTaskById(taskId),
+      cancel: (taskId) => this.cancelTaskRequest(taskId),
+      sendUpdate: (input) => this.sendThreadUpdate(input)
+    };
+    this.chats = createChatsApi({
+      baseUrl: this.baseUrl,
+      auth: this.auth,
+      app: this.app
+    });
+  }
+  authHeaders(extra) {
+    return {
+      "Content-Type": "application/json",
+      ...buildRobotRockAuthHeaders(this.auth),
+      ...extra
+    };
+  }
+  async createTaskRequest(task) {
+    const normalizedTask = normalizeSendToHumanInput(task, {
+      webhook: this.webhook,
+      app: this.app,
+      contextVersion: this.contextVersion,
+      agentVersion: this.agentVersion
+    });
+    const agentVersion = task.version ?? this.agentVersion;
+    const bodyPayload = {
+      ...normalizedTask,
+      ...task.assignTo !== void 0 ? { assignTo: task.assignTo } : {},
+      ...task.threadId !== void 0 ? { threadId: task.threadId } : {},
+      ...task.priority !== void 0 ? { priority: task.priority } : {},
+      ...task.update !== void 0 ? { update: task.update } : {},
+      ...agentVersion !== void 0 ? { agent: { version: agentVersion } } : {}
+    };
+    const validation = createTaskBodySchema2.safeParse(bodyPayload);
+    if (!validation.success) {
+      throw new RobotRockError(
+        `Invalid task: ${validation.error.issues[0]?.message}`,
+        400,
+        validation.error.issues
+      );
+    }
+    const headers = this.authHeaders(
+      task.idempotencyKey ? { "Idempotency-Key": task.idempotencyKey } : void 0
+    );
+    const response = await fetch(`${this.baseUrl}/`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(validation.data)
+    });
+    const data = await parseResponseBody(response);
+    if (!response.ok) {
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to create task"),
+        response.status,
+        data
+      );
+    }
+    return data.task;
+  }
+  async sendToHuman(task) {
+    const normalizedTask = normalizeSendToHumanInput(task, {
+      webhook: this.webhook,
+      app: this.app,
+      contextVersion: this.contextVersion,
+      agentVersion: this.agentVersion
+    });
+    const createdTaskTask = await this.createTaskRequest(task);
+    const hasHandlers = normalizedTask.actions.some(
+      (action) => Array.isArray(action.handlers) && action.handlers.length > 0
+    );
+    if (hasHandlers) {
+      return {
+        mode: "created",
+        task: createdTaskTask
+      };
+    }
+    const timeoutMs = this.polling.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const pollIntervalMs = this.polling.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const pollingDeadline = Date.now() + timeoutMs;
+    const validUntilMs = parseValidUntilMs(createdTaskTask.validUntil);
+    const deadline = validUntilMs !== void 0 ? Math.min(pollingDeadline, validUntilMs) : pollingDeadline;
+    const taskId = createdTaskTask.taskId;
+    while (Date.now() < deadline) {
+      const existing = await this.getTaskById(taskId);
+      if (existing?.status === "handled" && existing.handled) {
+        return {
+          mode: "handled",
+          task: createdTaskTask,
+          ...toDiscriminatedApprovalResult(
+            normalizedTask.actions,
+            existing
+          )
+        };
+      }
+      if (existing?.status === "expired" || existing && Date.now() >= existing.validUntil) {
+        throw new TaskExpiredError("Task reached validUntil before a human completed it");
+      }
+      const remainingMs = deadline - Date.now();
+      await sleep(Math.min(pollIntervalMs, Math.max(0, remainingMs)));
+    }
+    if (validUntilMs !== void 0 && Date.now() >= validUntilMs) {
+      throw new TaskExpiredError("Task reached validUntil before a human completed it");
+    }
+    throw new TaskTimeoutError(`No human response within ${timeoutMs}ms`);
+  }
+  /**
+   * Create a task via POST /v1 without waiting for a human response.
+   * @deprecated Use `client.tasks.create()` instead.
+   */
+  async createTask(task) {
+    return this.tasks.create(task);
+  }
+  /**
+   * Get a task by public task id (returned as `task.taskId` from {@link sendToHuman}).
+   * @deprecated Use `client.tasks.get()` instead.
+   */
+  async getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+  /**
+   * Log a status update against a thread.
+   * @deprecated Use `client.tasks.sendUpdate()` instead.
+   */
+  async sendUpdate(input) {
+    return this.tasks.sendUpdate(input);
+  }
+  /**
+   * Cancel a task by public task id.
+   * @deprecated Use `client.tasks.cancel()` instead.
+   */
+  async cancelTask(taskId) {
+    return this.tasks.cancel(taskId);
+  }
+  async getTaskById(taskId) {
+    const response = await fetch(`${this.baseUrl}/tasks/${taskId}`, {
+      method: "GET",
+      headers: this.authHeaders()
+    });
+    if (response.status === 404) {
+      return null;
+    }
+    const data = await parseResponseBody(response);
+    if (!response.ok) {
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to get task"),
+        response.status,
+        data
+      );
+    }
+    return data;
+  }
+  async sendThreadUpdate({
+    threadId,
+    message,
+    status
+  }) {
+    if (!threadId) {
+      throw new RobotRockError("threadId is required to send an update", 400);
+    }
+    const validation = threadUpdateBodySchema.safeParse({ message, status });
+    if (!validation.success) {
+      throw new RobotRockError(
+        `Invalid update: ${validation.error.issues[0]?.message}`,
+        400,
+        validation.error.issues
+      );
+    }
+    const response = await fetch(
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/updates`,
+      {
+        method: "POST",
+        headers: this.authHeaders(),
+        body: JSON.stringify(validation.data)
+      }
+    );
+    const data = await parseResponseBody(response);
+    if (!response.ok) {
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to send update"),
+        response.status,
+        data
+      );
+    }
+    return data.update;
+  }
+  async cancelTaskRequest(taskId) {
+    const response = await fetch(`${this.baseUrl}/tasks/${taskId}/cancel`, {
+      method: "POST",
+      headers: this.authHeaders()
+    });
+    if (!response.ok) {
+      const data = await parseResponseBody(response);
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to cancel task"),
+        response.status,
+        data
+      );
+    }
+  }
+};
+function createClient(config) {
+  return new RobotRock(config);
+}
+function attachWebhookToActions(actions, webhook) {
+  return actions.map((action) => ({
+    ...action,
+    handlers: webhookToHandlers(webhook)
+  }));
+}
+function webhookToHandlers(webhook) {
+  return [
+    {
+      type: "webhook",
+      url: webhook.url,
+      headers: webhook.headers ?? {}
+    }
+  ];
+}
+function normalizeSendToHumanInput(task, clientDefaults) {
+  const {
+    actions,
+    idempotencyKey: _idempotencyKey,
+    assignTo: _assignTo,
+    threadId: _threadId,
+    priority: _priority,
+    update: _update,
+    version: _version,
+    validUntil,
+    app: taskApp,
+    ...rest
+  } = task;
+  const webhook = clientDefaults.webhook;
+  const normalizedActions = webhook ? attachWebhookToActions(actions, webhook) : actions;
+  const app = taskApp ?? clientDefaults.app;
+  return {
+    ...rest,
+    contextVersion: clientDefaults.contextVersion,
+    ...app ? { app } : {},
+    ...validUntil !== void 0 ? { validUntil: serializeValidUntil(validUntil) } : {},
+    actions: normalizedActions
+  };
+}
+
+// src/env.ts
+function resolveRobotRockConfig(overrides) {
+  const agentService = overrides?.agentService;
+  const apiKey = overrides?.apiKey ?? process.env.ROBOTROCK_API_KEY;
+  if (agentService && apiKey) {
+    throw new Error(
+      "RobotRock client cannot configure both apiKey and agentService."
+    );
+  }
+  const baseUrl = overrides?.baseUrl ?? getRobotRockApiBaseUrl();
+  const app = overrides?.app ?? process.env.ROBOTROCK_APP;
+  if (agentService) {
+    return app ? { agentService, baseUrl, app } : { agentService, baseUrl };
+  }
+  if (!apiKey) {
+    throw new Error(
+      "RobotRock API key is required. Set ROBOTROCK_API_KEY or pass agentService when creating the client."
+    );
+  }
+  return app ? { apiKey, baseUrl, app } : { apiKey, baseUrl };
+}
+
+// src/eve/agent/client-from-session.ts
+var warnedMissingAuth = false;
+function tryCreateBoundRobotRockClient(ctx) {
+  const caller = tryResolveTenantCaller(ctx);
+  const serviceToken = process.env.ROBOTROCK_AGENT_SERVICE_TOKEN?.trim();
+  if (caller?.connectionId && serviceToken) {
+    return createClient({
+      baseUrl: process.env.ROBOTROCK_BASE_URL?.trim(),
+      agentService: {
+        token: serviceToken,
+        tenantSlug: caller.tenantSlug,
+        connectionId: caller.connectionId
+      }
+    });
+  }
+  const apiKey = process.env.ROBOTROCK_API_KEY?.trim();
+  if (apiKey) {
+    return createClient(
+      resolveRobotRockConfig({
+        apiKey,
+        baseUrl: process.env.ROBOTROCK_BASE_URL?.trim()
+      })
+    );
+  }
+  if (!warnedMissingAuth) {
+    warnedMissingAuth = true;
+    console.warn(
+      "robotrock: set ROBOTROCK_AGENT_SERVICE_TOKEN for hosted multi-tenant auth, or ROBOTROCK_API_KEY for single-tenant deployments."
+    );
+  }
+  return null;
+}
+function resetBoundClientAuthWarning() {
+  warnedMissingAuth = false;
+}
+
+// src/eve/agent/chat-audit-api.ts
+var warnedMissingAuth2 = false;
+var warnedConnectionRefused = false;
+function isConnectionRefused(error) {
+  const inspect = (value) => {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    if ("code" in value && value.code === "ECONNREFUSED") {
+      return true;
+    }
+    if ("cause" in value) {
+      return inspect(value.cause);
+    }
+    if ("errors" in value && Array.isArray(value.errors)) {
+      return value.errors.some((entry) => inspect(entry));
+    }
+    return false;
+  };
+  return inspect(error);
+}
+function logAuditFailure(label, error) {
+  if (isConnectionRefused(error)) {
+    if (!warnedConnectionRefused) {
+      warnedConnectionRefused = true;
+      console.warn(
+        "robotrock-chat-audit: RobotRock API is not reachable (connection refused). Audit and task-link calls are skipped until the API is up."
+      );
+    }
+    return;
+  }
+  const hint = error instanceof RobotRockError && error.statusCode === 405 ? " \u2014 set ROBOTROCK_BASE_URL=http://localhost:4001/v1 and run the local API" : "";
+  console.warn(`robotrock-chat-audit: failed to ${label}${hint}`, error);
+}
+async function postRobotRockChatInputAudit(ctx, payload) {
+  const client = tryCreateBoundRobotRockClient(ctx);
+  if (!client) {
+    if (!warnedMissingAuth2) {
+      warnedMissingAuth2 = true;
+      console.warn(
+        "robotrock-chat-audit: RobotRock auth is unset; skipping HITL audit logging."
+      );
+    }
+    return;
+  }
+  try {
+    await client.chats.logInputSubmission(payload);
+  } catch (error) {
+    logAuditFailure("log input submission", error);
+  }
+}
+async function postRobotRockStageHitl(ctx, input) {
+  const client = tryCreateBoundRobotRockClient(ctx);
+  if (!client) {
+    return;
+  }
+  if (input.requests.length === 0) {
+    return;
+  }
+  try {
+    await client.chats.stageHitlRequests(input);
+  } catch (error) {
+    logAuditFailure("stage HITL requests", error);
+  }
+}
+async function fetchRobotRockStagedHitl(ctx, eveSessionId) {
+  const client = tryCreateBoundRobotRockClient(ctx);
+  if (!client) {
+    return [];
+  }
+  try {
+    return await client.chats.getStagedHitlRequests(eveSessionId);
+  } catch (error) {
+    logAuditFailure("fetch staged HITL requests", error);
+    return [];
+  }
+}
+async function postRobotRockLinkChatTask(ctx, input) {
+  const client = tryCreateBoundRobotRockClient(ctx);
+  if (!client) {
+    if (!warnedMissingAuth2) {
+      warnedMissingAuth2 = true;
+      console.warn(
+        "robotrock-task-link: RobotRock auth is unset; skipping chat task link."
+      );
+    }
+    return;
+  }
+  try {
+    await client.chats.linkTask(input);
+  } catch (error) {
+    logAuditFailure("link task to chat", error);
+  }
+}
+function resetChatAuditWarnings() {
+  warnedMissingAuth2 = false;
+  warnedConnectionRefused = false;
+}
+
+// src/eve/agent/task-delegation.ts
+function resolveTaskApp(app) {
+  return app?.trim() || process.env.ROBOTROCK_APP?.trim() || "robotrock-agent";
+}
+function resolveWebhookBaseUrl(baseUrl) {
+  return baseUrl?.trim() || process.env.ROBOTROCK_BASE_URL?.trim() || "http://localhost:4001/v1";
+}
+function resolveTaskHandledWebhookUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  const withV1 = trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+  return `${withV1}/agent-chats/task-handled`;
+}
+function requireBoundClient(ctx) {
+  const client = tryCreateBoundRobotRockClient(ctx);
+  if (!client) {
+    throw new Error(
+      "RobotRock auth is unset. Configure ROBOTROCK_AGENT_SERVICE_TOKEN for hosted agents or ROBOTROCK_API_KEY for self-hosted deployments."
+    );
+  }
+  return client;
+}
+async function createRobotRockTask(input, ctx) {
+  const client = requireBoundClient(ctx);
+  const { app, ...taskInput } = input;
+  const resolvedApp = resolveTaskApp(app);
+  const webhookUrl = resolveTaskHandledWebhookUrl(
+    resolveWebhookBaseUrl(process.env.ROBOTROCK_BASE_URL)
+  );
+  try {
+    const task = await client.tasks.create({
+      ...taskInput,
+      app: resolvedApp,
+      actions: attachWebhookToActions(taskInput.actions, {
+        url: webhookUrl,
+        headers: {}
+      })
+    });
+    return {
+      taskId: task.taskId,
+      threadId: task.threadId,
+      status: task.status,
+      validUntil: task.validUntil,
+      submittedAt: task.submittedAt
+    };
+  } catch (error) {
+    const caller = tryResolveTenantCaller(ctx);
+    if (error instanceof RobotRockError) {
+      const response = error.response && typeof error.response === "object" ? error.response : void 0;
+      console.error("[create_robotrock_task] API request failed", {
+        status: error.statusCode,
+        message: error.message,
+        code: response?.code,
+        hint: response?.hint,
+        tenantSlug: caller?.tenantSlug,
+        connectionId: caller?.connectionId,
+        baseUrl: process.env.ROBOTROCK_BASE_URL?.trim() || null
+      });
+    } else {
+      console.error("[create_robotrock_task] unexpected error", error);
+    }
+    throw error;
+  }
+}
+function buildRobotRockTaskPayload(input, options) {
+  const contextData = {
+    ...input.context?.data ?? {}
+  };
+  if (options?.requestedByEmail) {
+    contextData.requestedBy = options.requestedByEmail;
+  }
+  const hasContext = Object.keys(contextData).length > 0 || input.context?.ui && Object.keys(input.context.ui).length > 0;
+  const payload = {
+    type: input.type,
+    name: input.name,
+    ...input.description ? { description: input.description } : {},
+    actions: input.actions.map((action) => ({
+      id: action.id,
+      title: action.title,
+      ...action.description ? { description: action.description } : {}
+    })),
+    ...input.assignTo ? { assignTo: input.assignTo } : {},
+    ...input.priority ? { priority: input.priority } : {},
+    ...input.app ? { app: input.app } : {},
+    ...input.validUntilHours ? {
+      validUntil: new Date(Date.now() + input.validUntilHours * 60 * 60 * 1e3)
+    } : {},
+    ...input.updateMessage ? {
+      update: {
+        message: input.updateMessage,
+        status: "waiting"
+      }
+    } : {}
+  };
+  if (hasContext) {
+    payload.context = {
+      data: contextData,
+      ...input.context?.ui ? { ui: input.context.ui } : {}
+    };
+  }
+  return payload;
+}
+
+// src/eve/agent/cron-chat.ts
+function resolveCronAgentIdentifier(agentIdentifier) {
+  return agentIdentifier?.trim() || process.env.ROBOTROCK_CRON_AGENT_IDENTIFIER?.trim() || "robotrock-agent";
+}
+async function createRobotRockCronChat(input) {
+  const apiKey = process.env.ROBOTROCK_API_KEY?.trim();
+  if (!apiKey) {
+    throw new Error("ROBOTROCK_API_KEY is unset");
+  }
+  const client = createClient(resolveRobotRockConfig({ apiKey }));
+  return client.chats.create({
+    agentIdentifier: resolveCronAgentIdentifier(input.agentIdentifier),
+    title: input.title,
+    messages: input.messages,
+    source: "cron",
+    assignTo: input.assignTo
+  });
+}
+
+// src/eve/agent/hooks/ready.ts
+import { defineHook } from "eve/hooks";
+var robotrockReadyHook = defineHook({});
+function defineRobotRockReadyHook() {
+  return defineHook({});
+}
+
+// src/eve/agent/hooks/chat-audit.ts
+import { defineHook as defineHook2 } from "eve/hooks";
+var loggedIdempotencyKeys = /* @__PURE__ */ new Set();
+function toEveInputRequest(request) {
+  return {
+    requestId: request.requestId,
+    prompt: request.prompt,
+    ...request.display ? { display: request.display } : {},
+    ...request.allowFreeform !== void 0 ? { allowFreeform: request.allowFreeform } : {},
+    ...request.options ? { options: request.options } : {}
+  };
+}
+async function logPendingInputResponse(ctx, pending, response) {
+  const caller = tryResolveTenantCaller(ctx);
+  if (!caller) {
+    return;
+  }
+  const idempotencyKey = `${ctx.session.id}:${pending.requestId}`;
+  if (loggedIdempotencyKeys.has(idempotencyKey)) {
+    return;
+  }
+  const eveRequest = toEveInputRequest(pending);
+  const submission = eveInputResponseToActionSubmission(eveRequest, response, {
+    toolName: pending.toolName
+  });
+  const toolInput = pending.display === "confirmation" ? pending.toolInput : void 0;
+  await postRobotRockChatInputAudit(ctx, {
+    eveSessionId: ctx.session.id,
+    userId: caller.userId,
+    actionId: submission.actionId,
+    actionTitle: submission.actionTitle,
+    prompt: pending.prompt,
+    requestId: pending.requestId,
+    toolCallId: pending.toolCallId,
+    data: buildEveInputAuditSubmissionData(
+      {
+        toolCallId: pending.toolCallId,
+        toolName: pending.toolName,
+        requestId: pending.requestId,
+        display: pending.display,
+        toolInput
+      },
+      submission.formData
+    ),
+    idempotencyKey
+  });
+  loggedIdempotencyKeys.add(idempotencyKey);
+}
+function resetRobotrockChatAuditIdempotencyKeys() {
+  loggedIdempotencyKeys.clear();
+}
+var robotrockChatAuditHook = defineHook2({
+  events: {
+    async "input.requested"(event, ctx) {
+      const requests = [];
+      for (const request of event.data.requests) {
+        if (request.action.kind !== "tool-call") {
+          continue;
+        }
+        requests.push({
+          requestId: request.requestId,
+          prompt: request.prompt,
+          toolName: request.action.toolName,
+          toolCallId: request.action.callId,
+          ...request.display ? { display: request.display } : {},
+          ...request.allowFreeform !== void 0 ? { allowFreeform: request.allowFreeform } : {},
+          ...request.options ? { options: request.options } : {},
+          ...request.action.input !== void 0 ? {
+            toolInput: request.action.input != null && typeof request.action.input === "object" && !Array.isArray(request.action.input) ? request.action.input : void 0
+          } : {}
+        });
+      }
+      await postRobotRockStageHitl(ctx, {
+        eveSessionId: ctx.session.id,
+        requests
+      });
+    },
+    async "message.received"(event, ctx) {
+      const message = event.data.message?.trim();
+      if (!message) {
+        return;
+      }
+      const staged = await fetchRobotRockStagedHitl(ctx, ctx.session.id);
+      for (const pending of staged) {
+        const response = resolveEveFreeformTextToInputResponse(
+          toEveInputRequest(pending),
+          message
+        );
+        if (!response) {
+          continue;
+        }
+        await logPendingInputResponse(ctx, pending, response);
+      }
+    },
+    async "action.result"(event, ctx) {
+      const result = event.data.result;
+      if (result.kind !== "tool-result") {
+        return;
+      }
+      const staged = await fetchRobotRockStagedHitl(ctx, ctx.session.id);
+      const pending = staged.find((entry) => entry.toolCallId === result.callId);
+      if (!pending) {
+        return;
+      }
+      const idempotencyKey = `${ctx.session.id}:${pending.requestId}`;
+      if (loggedIdempotencyKeys.has(idempotencyKey)) {
+        return;
+      }
+      if (pending.toolName === "ask_question") {
+        const parsed = parseEveAskQuestionToolOutput(result.output);
+        if (!parsed) {
+          return;
+        }
+        await logPendingInputResponse(ctx, pending, {
+          requestId: pending.requestId,
+          ...parsed
+        });
+        return;
+      }
+      if (!isEveApprovalInputRequest(toEveInputRequest(pending))) {
+        return;
+      }
+      if (event.data.status === "rejected") {
+        await logPendingInputResponse(ctx, pending, {
+          requestId: pending.requestId,
+          optionId: "deny"
+        });
+        return;
+      }
+      if (event.data.status === "completed") {
+        await logPendingInputResponse(ctx, pending, {
+          requestId: pending.requestId,
+          optionId: "approve"
+        });
+      }
+    }
+  }
+});
+function defineRobotRockChatAuditHook() {
+  return robotrockChatAuditHook;
+}
+export {
+  ROBOTROCK_PLATFORM_USER_CONTEXT_PUBLIC_KEY_URL,
+  ROBOTROCK_READY_HOOK_SLUG,
+  ROBOTROCK_USER_CONTEXT_AUDIENCE,
+  ROBOTROCK_USER_CONTEXT_HEADER,
+  ROBOTROCK_USER_CONTEXT_ISSUER,
+  buildRobotRockTaskPayload,
+  createRobotRockCronChat,
+  createRobotRockTask,
+  defineRobotRockChatAuditHook,
+  defineRobotRockReadyHook,
+  eveSelfServiceAuth,
+  fetchRobotRockStagedHitl,
+  isAdminCaller,
+  postRobotRockChatInputAudit,
+  postRobotRockLinkChatTask,
+  postRobotRockStageHitl,
+  requireAdminCaller,
+  requireTenantCaller,
+  resetBoundClientAuthWarning,
+  resetChatAuditWarnings,
+  resetRobotrockChatAuditIdempotencyKeys,
+  resolvePlatformUserContextPublicKeyPem,
+  resolveTaskHandledWebhookUrl,
+  robotrockAgentServiceAuth,
+  robotrockChatAuditHook,
+  robotrockEveChannel,
+  robotrockReadyHook,
+  robotrockUserContextAuth,
+  tryCreateBoundRobotRockClient,
+  tryResolveTenantCaller
+};
+//# sourceMappingURL=index.js.map