@elizaos/plugin-personal-assistant 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/actions/document.js

@@ -0,0 +1,613 @@
+import { logger } from "@elizaos/core";
+import { hasLifeOpsAccess } from "../lifeops/access.js";
+import { createApprovalQueue } from "../lifeops/approval-queue.js";
+import { getScheduledTaskRunner } from "../lifeops/scheduled-task/service.js";
+const ACTION_NAME = "OWNER_DOCUMENTS";
+const SUBACTIONS = [
+  "request_signature",
+  "request_approval",
+  "track_deadline",
+  "upload_asset",
+  "collect_id",
+  "close_request"
+];
+const SIMILE_NAMES = [
+  "OWNER_DOCUMENTS_REQUEST_SIGNATURE",
+  "OWNER_DOCUMENTS_REQUEST_APPROVAL",
+  "OWNER_DOCUMENTS_TRACK_DEADLINE",
+  "OWNER_DOCUMENTS_UPLOAD_ASSET",
+  "OWNER_DOCUMENTS_COLLECT_ID_OR_FORM",
+  "OWNER_DOCUMENTS_CLOSE_REQUEST",
+  "PAPERWORK"
+];
+const SIMILE_TO_SUBACTION = {
+  OWNER_DOCUMENTS_REQUEST_SIGNATURE: "request_signature",
+  OWNER_DOCUMENTS_REQUEST_APPROVAL: "request_approval",
+  OWNER_DOCUMENTS_TRACK_DEADLINE: "track_deadline",
+  OWNER_DOCUMENTS_UPLOAD_ASSET: "upload_asset",
+  OWNER_DOCUMENTS_COLLECT_ID_OR_FORM: "collect_id",
+  OWNER_DOCUMENTS_CLOSE_REQUEST: "close_request"
+};
+const DOCUMENT_STORE = /* @__PURE__ */ new Map();
+function getDocStore(runtime) {
+  const key = String(runtime.agentId);
+  let store = DOCUMENT_STORE.get(key);
+  if (!store) {
+    store = /* @__PURE__ */ new Map();
+    DOCUMENT_STORE.set(key, store);
+  }
+  return store;
+}
+function newDocumentRequestId() {
+  return `doc-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function normalizeSubaction(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  const upper = trimmed.toUpperCase();
+  if (upper in SIMILE_TO_SUBACTION) {
+    return SIMILE_TO_SUBACTION[upper] ?? null;
+  }
+  const lower = trimmed.toLowerCase();
+  return SUBACTIONS.includes(lower) ? lower : null;
+}
+function resolveSubaction(params) {
+  return normalizeSubaction(params.subaction) ?? normalizeSubaction(params.action) ?? normalizeSubaction(params.op);
+}
+function getParams(options) {
+  const raw = options?.parameters;
+  if (raw && typeof raw === "object") {
+    return raw;
+  }
+  return {};
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function kindForSubaction(subaction) {
+  switch (subaction) {
+    case "request_signature":
+      return "signature";
+    case "request_approval":
+      return "approval";
+    case "upload_asset":
+      return "upload";
+    case "collect_id":
+      return "collect_id";
+    case "track_deadline":
+    case "close_request":
+      return "signature";
+  }
+}
+function missing(name, subaction) {
+  return {
+    success: false,
+    text: `I need ${name} to ${subaction.replace("_", " ")}.`,
+    data: { subaction, error: `MISSING_${name.toUpperCase()}` }
+  };
+}
+function notFound(documentRequestId, subaction) {
+  return {
+    success: false,
+    text: `No DocumentRequest found with id ${documentRequestId}.`,
+    data: { subaction, error: "DOCUMENT_REQUEST_NOT_FOUND" }
+  };
+}
+function saveDocument(runtime, doc) {
+  const store = getDocStore(runtime);
+  store.set(doc.id, doc);
+  return doc;
+}
+function patchDocument(runtime, id, patch) {
+  const store = getDocStore(runtime);
+  const existing = store.get(id);
+  if (!existing) return null;
+  const next = {
+    ...existing,
+    ...patch,
+    id: existing.id,
+    createdAt: existing.createdAt,
+    updatedAt: nowIso()
+  };
+  store.set(id, next);
+  return next;
+}
+function makeScope(runtime, message) {
+  const agentId = String(runtime.agentId);
+  const runner = getScheduledTaskRunner(runtime, { agentId });
+  const subjectUserId = typeof message.entityId === "string" && message.entityId.length > 0 ? message.entityId : agentId;
+  return { runtime, runner, agentId, subjectUserId };
+}
+async function scheduleDeadlineTask(scope, doc) {
+  if (!doc.deadline) return void 0;
+  const trigger = {
+    kind: "once",
+    atIso: doc.deadline
+  };
+  const task = await scope.runner.schedule({
+    kind: "watcher",
+    promptInstructions: `Document "${doc.title}" deadline reached. Verify status of DocumentRequest ${doc.id} and escalate if still ${doc.status}.`,
+    trigger,
+    priority: "medium",
+    subject: { kind: "document", id: doc.id },
+    metadata: {
+      documentRequestId: doc.id,
+      documentKind: doc.kind
+    },
+    respectsGlobalPause: true,
+    source: "user_chat",
+    createdBy: scope.agentId,
+    ownerVisible: true
+  });
+  return task.taskId;
+}
+async function handleRequestSignature(scope, params) {
+  const subaction = "request_signature";
+  const requesteeEntityId = params.requesteeEntityId?.trim();
+  if (!requesteeEntityId) return missing("requesteeEntityId", subaction);
+  const documentTitle = params.documentTitle?.trim();
+  if (!documentTitle) return missing("documentTitle", subaction);
+  const deadline = params.deadline?.trim();
+  if (!deadline) return missing("deadline", subaction);
+  const now = nowIso();
+  const doc = {
+    id: newDocumentRequestId(),
+    kind: "signature",
+    requesteeEntityId,
+    title: documentTitle,
+    deadline,
+    status: "draft",
+    createdAt: now,
+    updatedAt: now,
+    createdBy: scope.agentId,
+    ...params.note ? { note: params.note } : {}
+  };
+  const queue = createApprovalQueue(scope.runtime, { agentId: scope.agentId });
+  const approvalRequest = await queue.enqueue({
+    requestedBy: ACTION_NAME,
+    subjectUserId: scope.subjectUserId,
+    action: "sign_document",
+    payload: {
+      action: "sign_document",
+      documentId: doc.id,
+      documentName: doc.title,
+      signatureUrl: params.signatureUrl?.trim() ?? "",
+      deadline
+    },
+    channel: "internal",
+    reason: `Request signature from ${requesteeEntityId} on "${doc.title}" by ${deadline}`,
+    expiresAt: new Date(
+      Date.parse(deadline) || Date.now() + 24 * 60 * 60 * 1e3
+    )
+  });
+  const scheduledTaskId = await scheduleDeadlineTask(scope, doc);
+  const saved = saveDocument(scope.runtime, {
+    ...doc,
+    status: "pending",
+    approvalRequestId: approvalRequest.id,
+    ...scheduledTaskId ? { scheduledTaskId } : {}
+  });
+  logger.info(
+    `[OWNER_DOCUMENTS] request_signature id=${saved.id} requestee=${requesteeEntityId} deadline=${deadline} approval=${approvalRequest.id}`
+  );
+  return {
+    success: true,
+    text: `Queued signature request for "${saved.title}" pending owner approval.`,
+    data: {
+      subaction,
+      documentRequest: saved,
+      documentRequestId: saved.id,
+      status: saved.status,
+      approvalRequestId: approvalRequest.id,
+      scheduledTaskId: saved.scheduledTaskId ?? null
+    }
+  };
+}
+async function handleRequestApproval(scope, params) {
+  const subaction = "request_approval";
+  const documentTitle = params.documentTitle?.trim();
+  if (!documentTitle) return missing("documentTitle", subaction);
+  const now = nowIso();
+  const doc = {
+    id: newDocumentRequestId(),
+    kind: "approval",
+    title: documentTitle,
+    status: "pending",
+    createdAt: now,
+    updatedAt: now,
+    createdBy: scope.agentId,
+    ...params.requesteeEntityId ? { requesteeEntityId: params.requesteeEntityId.trim() } : {},
+    ...params.deadline ? { deadline: params.deadline.trim() } : {},
+    ...params.note ? { note: params.note } : {}
+  };
+  const scheduledTaskId = await scheduleDeadlineTask(scope, doc);
+  const saved = saveDocument(scope.runtime, {
+    ...doc,
+    ...scheduledTaskId ? { scheduledTaskId } : {}
+  });
+  logger.info(
+    `[OWNER_DOCUMENTS] request_approval id=${saved.id} title="${documentTitle}" reason=${params.approvalReason ?? "(none)"}`
+  );
+  return {
+    success: true,
+    text: `Logged approval request for "${saved.title}".`,
+    data: {
+      subaction,
+      documentRequest: saved,
+      documentRequestId: saved.id,
+      status: saved.status,
+      scheduledTaskId: saved.scheduledTaskId ?? null
+    }
+  };
+}
+async function handleTrackDeadline(scope, params) {
+  const subaction = "track_deadline";
+  const documentRequestId = params.documentRequestId?.trim();
+  if (!documentRequestId) return missing("documentRequestId", subaction);
+  const store = getDocStore(scope.runtime);
+  const existing = store.get(documentRequestId);
+  if (!existing) return notFound(documentRequestId, subaction);
+  const deadline = params.deadline?.trim() ?? existing.deadline;
+  if (!deadline) return missing("deadline", subaction);
+  const patched = patchDocument(scope.runtime, documentRequestId, {
+    deadline,
+    status: existing.status === "draft" ? "pending" : existing.status
+  });
+  if (!patched) return notFound(documentRequestId, subaction);
+  const scheduledTaskId = await scheduleDeadlineTask(scope, patched);
+  const next = patchDocument(scope.runtime, documentRequestId, {
+    ...scheduledTaskId ? { scheduledTaskId } : {}
+  });
+  if (!next) return notFound(documentRequestId, subaction);
+  logger.info(
+    `[OWNER_DOCUMENTS] track_deadline id=${next.id} deadline=${deadline} task=${scheduledTaskId ?? "(none)"}`
+  );
+  return {
+    success: true,
+    text: `Tracking ${next.title} deadline ${deadline}.`,
+    data: {
+      subaction,
+      documentRequest: next,
+      documentRequestId: next.id,
+      status: next.status,
+      scheduledTaskId: next.scheduledTaskId ?? null
+    }
+  };
+}
+async function handleUploadAsset(scope, params) {
+  const subaction = "upload_asset";
+  const portalUrl = params.portalUrl?.trim();
+  if (!portalUrl) return missing("portalUrl", subaction);
+  const assetPath = params.assetPath?.trim();
+  if (!assetPath) return missing("assetPath", subaction);
+  const assetKind = params.assetKind?.trim();
+  if (!assetKind) return missing("assetKind", subaction);
+  const documentTitle = params.documentTitle?.trim() ?? `Upload ${assetKind} to ${portalUrl}`;
+  const now = nowIso();
+  const doc = {
+    id: newDocumentRequestId(),
+    kind: "upload",
+    title: documentTitle,
+    portalUrl,
+    assetKind,
+    status: "draft",
+    createdAt: now,
+    updatedAt: now,
+    createdBy: scope.agentId,
+    ...params.deadline ? { deadline: params.deadline.trim() } : {},
+    ...params.requesteeEntityId ? { requesteeEntityId: params.requesteeEntityId.trim() } : {},
+    ...params.note ? { note: params.note } : {}
+  };
+  const queue = createApprovalQueue(scope.runtime, { agentId: scope.agentId });
+  const approvalRequest = await queue.enqueue({
+    requestedBy: ACTION_NAME,
+    subjectUserId: scope.subjectUserId,
+    action: "execute_workflow",
+    payload: {
+      action: "execute_workflow",
+      workflowId: "doc.upload_asset",
+      input: {
+        documentId: doc.id,
+        portalUrl,
+        assetPath,
+        assetKind
+      }
+    },
+    channel: "browser",
+    reason: `Upload ${assetKind} to ${portalUrl}`,
+    expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
+  });
+  const scheduledTaskId = await scheduleDeadlineTask(scope, doc);
+  const saved = saveDocument(scope.runtime, {
+    ...doc,
+    status: "pending",
+    approvalRequestId: approvalRequest.id,
+    ...scheduledTaskId ? { scheduledTaskId } : {}
+  });
+  logger.info(
+    `[OWNER_DOCUMENTS] upload_asset id=${saved.id} portal=${portalUrl} asset=${assetKind} approval=${approvalRequest.id}`
+  );
+  return {
+    success: true,
+    text: `Queued ${assetKind} upload to ${portalUrl} pending owner approval.`,
+    data: {
+      subaction,
+      documentRequest: saved,
+      documentRequestId: saved.id,
+      status: saved.status,
+      approvalRequestId: approvalRequest.id,
+      scheduledTaskId: saved.scheduledTaskId ?? null
+    }
+  };
+}
+async function handleCollectId(scope, params) {
+  const subaction = "collect_id";
+  const requesteeEntityId = params.requesteeEntityId?.trim();
+  if (!requesteeEntityId) return missing("requesteeEntityId", subaction);
+  const assetKind = params.assetKind?.trim();
+  if (!assetKind) return missing("assetKind", subaction);
+  const now = nowIso();
+  const doc = {
+    id: newDocumentRequestId(),
+    kind: "collect_id",
+    requesteeEntityId,
+    title: params.documentTitle?.trim() ?? `Collect ${assetKind} from ${requesteeEntityId}`,
+    assetKind,
+    status: "pending",
+    createdAt: now,
+    updatedAt: now,
+    createdBy: scope.agentId,
+    ...params.portalUrl ? { portalUrl: params.portalUrl.trim() } : {},
+    ...params.deadline ? { deadline: params.deadline.trim() } : {},
+    ...params.note ? { note: params.note } : {}
+  };
+  const scheduledTaskId = await scheduleDeadlineTask(scope, doc);
+  const saved = saveDocument(scope.runtime, {
+    ...doc,
+    ...scheduledTaskId ? { scheduledTaskId } : {}
+  });
+  logger.info(
+    `[OWNER_DOCUMENTS] collect_id id=${saved.id} requestee=${requesteeEntityId} kind=${assetKind}`
+  );
+  return {
+    success: true,
+    text: `Tracking ${assetKind} collection from ${requesteeEntityId}.`,
+    data: {
+      subaction,
+      documentRequest: saved,
+      documentRequestId: saved.id,
+      status: saved.status,
+      scheduledTaskId: saved.scheduledTaskId ?? null
+    }
+  };
+}
+async function handleCloseRequest(scope, params) {
+  const subaction = "close_request";
+  const documentRequestId = params.documentRequestId?.trim();
+  if (!documentRequestId) return missing("documentRequestId", subaction);
+  const resolution = params.resolution ?? "completed";
+  if (resolution !== "completed" && resolution !== "expired" && resolution !== "cancelled") {
+    return {
+      success: false,
+      text: `Invalid resolution "${resolution}". Use completed | expired | cancelled.`,
+      data: { subaction, error: "INVALID_RESOLUTION" }
+    };
+  }
+  const patched = patchDocument(scope.runtime, documentRequestId, {
+    status: resolution
+  });
+  if (!patched) return notFound(documentRequestId, subaction);
+  if (patched.scheduledTaskId) {
+    try {
+      await scope.runner.apply(patched.scheduledTaskId, "dismiss", {
+        reason: `document ${resolution}`
+      });
+    } catch (error) {
+      logger.warn(
+        `[OWNER_DOCUMENTS] close_request failed to dismiss task ${patched.scheduledTaskId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  logger.info(
+    `[OWNER_DOCUMENTS] close_request id=${patched.id} resolution=${resolution}`
+  );
+  return {
+    success: true,
+    text: `Closed DocumentRequest ${patched.id} as ${resolution}.`,
+    data: {
+      subaction,
+      documentRequest: patched,
+      documentRequestId: patched.id,
+      status: patched.status
+    }
+  };
+}
+const examples = [
+  [
+    {
+      name: "{{name1}}",
+      content: {
+        text: "Get the NDA signed by Alice before Friday \u2014 she's at entity-alice-001."
+      }
+    },
+    {
+      name: "{{agentName}}",
+      content: {
+        text: "Queued signature request for the NDA pending owner approval.",
+        action: ACTION_NAME
+      }
+    }
+  ],
+  [
+    {
+      name: "{{name1}}",
+      content: {
+        text: "Upload the deck to the Solana Breakpoint speaker portal."
+      }
+    },
+    {
+      name: "{{agentName}}",
+      content: {
+        text: "Queued deck upload to the speaker portal pending owner approval.",
+        action: ACTION_NAME
+      }
+    }
+  ],
+  [
+    {
+      name: "{{name1}}",
+      content: { text: "Close out doc-abc123 \u2014 it's signed." }
+    },
+    {
+      name: "{{agentName}}",
+      content: {
+        text: "Closed DocumentRequest doc-abc123 as completed.",
+        action: ACTION_NAME
+      }
+    }
+  ]
+];
+const ownerDocumentsAction = {
+  name: ACTION_NAME,
+  similes: SIMILE_NAMES.slice(),
+  tags: [
+    "domain:docs",
+    "capability:read",
+    "capability:write",
+    "capability:update",
+    "capability:schedule",
+    "surface:internal"
+  ],
+  description: "Owner documents: signature requests, approvals, deadlines, portal uploads, ID/form collection, close-out. Ops: request_signature|request_approval|track_deadline|upload_asset|collect_id|close_request.",
+  descriptionCompressed: "OWNER_DOCUMENTS signature|approval|deadline|upload_asset|collect_id|close_request",
+  routingHint: 'owner document signature/approval/upload/portal/ID-form ("get signed", "send approval", "upload deck", "track NDA deadline", "close doc") -> OWNER_DOCUMENTS; approval queue resolution -> RESOLVE_REQUEST',
+  contexts: ["docs", "tasks", "calendar", "contacts"],
+  roleGate: { minRole: "OWNER" },
+  suppressPostActionContinuation: true,
+  validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
+  parameters: [
+    {
+      name: "action",
+      description: "Document op: request_signature|request_approval|track_deadline|upload_asset|collect_id|close_request.",
+      schema: { type: "string", enum: [...SUBACTIONS] }
+    },
+    {
+      name: "documentRequestId",
+      description: "Existing DocumentRequest id; required track_deadline/close_request.",
+      schema: { type: "string" }
+    },
+    {
+      name: "requesteeEntityId",
+      description: "Requestee Entity id; required request_signature/collect_id.",
+      schema: { type: "string" }
+    },
+    {
+      name: "documentTitle",
+      description: "Short doc label.",
+      schema: { type: "string" }
+    },
+    {
+      name: "deadline",
+      description: "Deadline ISO-8601.",
+      schema: { type: "string" }
+    },
+    {
+      name: "portalUrl",
+      description: "Portal URL; required upload_asset, optional collect_id.",
+      schema: { type: "string" }
+    },
+    {
+      name: "assetPath",
+      description: "Asset path/URL; required upload_asset.",
+      schema: { type: "string" }
+    },
+    {
+      name: "assetKind",
+      description: "Asset kind deck|headshot|id|form|etc.; required upload_asset/collect_id.",
+      schema: { type: "string" }
+    },
+    {
+      name: "signatureUrl",
+      description: "Optional signing portal URL: DocuSign|HelloSign|etc.",
+      schema: { type: "string" }
+    },
+    {
+      name: "approvalReason",
+      description: "request_approval reason label.",
+      schema: { type: "string" }
+    },
+    {
+      name: "note",
+      description: "Free-form DocumentRequest note.",
+      schema: { type: "string" }
+    },
+    {
+      name: "resolution",
+      description: "close_request only: completed|expired|cancelled; default completed.",
+      schema: {
+        type: "string",
+        enum: ["completed", "expired", "cancelled"]
+      }
+    }
+  ],
+  examples,
+  handler: async (runtime, message, _state, options, callback) => {
+    if (!await hasLifeOpsAccess(runtime, message)) {
+      const text = "Document workflow control is restricted to the owner.";
+      await callback?.({ text });
+      return { text, success: false, data: { error: "PERMISSION_DENIED" } };
+    }
+    const params = getParams(options);
+    const subaction = resolveSubaction(params);
+    if (!subaction) {
+      return {
+        success: false,
+        text: "Tell me which document operation: request_signature, request_approval, track_deadline, upload_asset, collect_id, or close_request.",
+        data: { error: "MISSING_SUBACTION" }
+      };
+    }
+    const scope = makeScope(runtime, message);
+    let result;
+    switch (subaction) {
+      case "request_signature":
+        result = await handleRequestSignature(scope, params);
+        break;
+      case "request_approval":
+        result = await handleRequestApproval(scope, params);
+        break;
+      case "track_deadline":
+        result = await handleTrackDeadline(scope, params);
+        break;
+      case "upload_asset":
+        result = await handleUploadAsset(scope, params);
+        break;
+      case "collect_id":
+        result = await handleCollectId(scope, params);
+        break;
+      case "close_request":
+        result = await handleCloseRequest(scope, params);
+        break;
+    }
+    if (result.text) {
+      await callback?.({
+        text: result.text,
+        source: "action",
+        action: ACTION_NAME
+      });
+    }
+    return result;
+  }
+};
+function __resetDocumentStoreForTests() {
+  DOCUMENT_STORE.clear();
+}
+function __kindForSubactionForTests(s) {
+  return kindForSubaction(s);
+}
+export {
+  __kindForSubactionForTests,
+  __resetDocumentStoreForTests,
+  ownerDocumentsAction
+};
+//# sourceMappingURL=document.js.map