@elizaos/plugin-inbox 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/inbox/service.js

@@ -0,0 +1,247 @@
+import { resolveKnowledgeGraphService } from "@elizaos/agent/services/knowledge-graph/service";
+import { logger, ServiceType } from "@elizaos/core";
+import { loadInboxTriageConfig } from "./config.js";
+import {
+  curateEmailCandidates
+} from "./email-curation.js";
+import { InboxRepository } from "./repository.js";
+import { classifyMessages } from "./triage-classifier.js";
+function normalizeSenderEmail(candidate) {
+  const raw = candidate.fromEmail ?? candidate.from;
+  if (!raw) return null;
+  const angle = raw.match(/<([^>]+)>/);
+  const value = (angle?.[1] ?? raw).trim().toLowerCase();
+  const email = value.match(/[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/i);
+  return email?.[0]?.toLowerCase() ?? null;
+}
+function entityToCurationIdentity(candidate) {
+  const { entity } = candidate;
+  const isVip = entity.tags.some((tag) => tag.toLowerCase() === "vip");
+  return {
+    kind: isVip ? "vip" : "known_person",
+    label: entity.preferredName,
+    matchedBy: ["knowledge_graph.identity.email"],
+    blockDelete: true,
+    personId: entity.entityId
+  };
+}
+function toCurationCandidate(message) {
+  return {
+    id: message.id,
+    ...message.threadId ? { threadId: message.threadId } : {},
+    subject: message.channelName,
+    snippet: message.snippet,
+    from: message.senderName,
+    ...message.senderEmail ? { fromEmail: message.senderEmail } : {},
+    bodyText: message.text,
+    receivedAt: new Date(message.timestamp).toISOString()
+  };
+}
+class InboxService {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.repository = new InboxRepository(runtime);
+  }
+  runtime;
+  repository;
+  getRepository() {
+    return this.repository;
+  }
+  /**
+   * Classify a batch of inbound messages and (unless `classifyOnly`) persist
+   * one triage entry per message. Returns the per-message decision in input
+   * order. Messages already triaged by `source_message_id` are skipped so a
+   * re-run does not double-store.
+   */
+  async triage(messages, opts = {}) {
+    if (messages.length === 0) return { triaged: [] };
+    const config = opts.config ?? loadInboxTriageConfig();
+    const examples = opts.classifyOnly ? [] : await this.repository.getExamples(opts.exampleLimit ?? 10);
+    const results = await classifyMessages(this.runtime, messages, {
+      config,
+      examples,
+      ...opts.ownerContext ? { ownerContext: opts.ownerContext } : {}
+    });
+    const triaged = [];
+    for (let i = 0; i < messages.length; i += 1) {
+      const message = messages[i];
+      const result = results[i];
+      if (!message || !result) continue;
+      const triagedMessage = {
+        message,
+        classification: result.classification,
+        urgency: result.urgency,
+        confidence: result.confidence,
+        reasoning: result.reasoning,
+        ...result.suggestedResponse ? { suggestedResponse: result.suggestedResponse } : {}
+      };
+      if (!opts.classifyOnly) {
+        const existing = message.id ? await this.repository.getBySourceMessageId(message.id) : null;
+        if (existing) {
+          triagedMessage.entry = existing;
+        } else {
+          const stored = await this.repository.storeTriage({
+            source: message.source,
+            ...message.roomId ? { sourceRoomId: message.roomId } : {},
+            ...message.entityId ? { sourceEntityId: message.entityId } : {},
+            ...message.id ? { sourceMessageId: message.id } : {},
+            channelName: message.channelName,
+            channelType: message.channelType,
+            ...message.deepLink ? { deepLink: message.deepLink } : {},
+            classification: result.classification,
+            urgency: result.urgency,
+            confidence: result.confidence,
+            snippet: message.snippet,
+            ...message.senderName ? { senderName: message.senderName } : {},
+            ...message.threadMessages && message.threadMessages.length > 0 ? { threadContext: message.threadMessages } : {},
+            ...result.reasoning ? { triageReasoning: result.reasoning } : {},
+            ...result.suggestedResponse ? { suggestedResponse: result.suggestedResponse } : {}
+          });
+          triagedMessage.entry = stored;
+          this.notifyAttention(stored);
+        }
+      }
+      triaged.push(triagedMessage);
+    }
+    return { triaged };
+  }
+  /**
+   * Surface an act-now triage entry (`urgent` / `needs_reply`) on the home
+   * notification rail. Best-effort: a runtime with no NotificationService (a
+   * headless/test runtime) is a no-op. `info`/`notify`/`ignore` stay in the
+   * inbox view without pushing a notification.
+   */
+  notifyAttention(entry) {
+    const isUrgent = entry.classification === "urgent";
+    if (!isUrgent && entry.classification !== "needs_reply") return;
+    const who = entry.senderName ? ` from ${entry.senderName}` : "";
+    this.runtime.getService(ServiceType.NOTIFICATION)?.notify({
+      title: isUrgent ? `Urgent message${who}` : `Message${who} needs a reply`,
+      body: entry.snippet,
+      category: "message",
+      priority: isUrgent ? "urgent" : "high",
+      source: "inbox",
+      groupKey: `inbox:${entry.id}`,
+      deepLink: entry.deepLink ?? "/inbox",
+      data: {
+        triageEntryId: entry.id,
+        classification: entry.classification,
+        channelName: entry.channelName
+      }
+    }).catch((error) => {
+      logger.debug({ src: "inbox", error }, "Triage notify failed");
+    });
+  }
+  /**
+   * Run the pure email-curation engine over a batch of inbound messages and
+   * return the per-candidate decision (save / archive / delete / review with
+   * evidence, citations, and a bulk-review block).
+   *
+   * This is the richer decision path that complements {@link triage}: triage
+   * answers "how urgent is this and should I reply", curation answers "what
+   * should happen to this message in the owner's mailbox". It does not persist
+   * anything — callers decide what to do with the suggested action.
+   *
+   * The identity hook is backed by the runtime knowledge-graph service so the
+   * sender's entity (VIP / known person / service) feeds the engine's
+   * delete-blockers. Both hooks are injectable as a test seam.
+   */
+  async curate(messages, opts = {}) {
+    const candidates = messages.map((message) => toCurationCandidate(message));
+    const identityHook = opts.identityHook ?? await this.buildKnowledgeGraphIdentityHook(candidates);
+    return curateEmailCandidates({
+      candidates,
+      identityHook,
+      ...opts.policyHook ? { policyHook: opts.policyHook } : {},
+      ...opts.policy ? { policy: opts.policy } : {},
+      ...opts.now ? { now: opts.now } : {}
+    });
+  }
+  /**
+   * Triage a batch, then attach a curation decision to each message in the
+   * same input order. Triage behavior is unchanged (the existing
+   * classification + persistence still runs); curation is additive.
+   */
+  async triageWithCuration(messages, opts = {}) {
+    const { identityHook, policyHook, policy, now, ...triageOpts } = opts;
+    const triageResult = await this.triage(messages, triageOpts);
+    const curation = await this.curate(messages, {
+      ...identityHook ? { identityHook } : {},
+      ...policyHook ? { policyHook } : {},
+      ...policy ? { policy } : {},
+      ...now ? { now } : {}
+    });
+    const decisionByCandidateId = new Map(
+      curation.decisions.flatMap(
+        (decision) => decision.canonicalMessageIds.map((id) => [id, decision])
+      )
+    );
+    const triaged = triageResult.triaged.flatMap(
+      (triagedMessage) => {
+        const decision = decisionByCandidateId.get(triagedMessage.message.id);
+        if (!decision) return [];
+        return [{ ...triagedMessage, curation: decision }];
+      }
+    );
+    return { triaged, curation };
+  }
+  /**
+   * Build an {@link EmailCurationIdentityHook} backed by the runtime
+   * knowledge-graph service. Pre-resolves every candidate's sender against the
+   * entity graph (the engine hook itself must be synchronous, so the async
+   * graph reads happen here) and maps the resolved entity onto the engine's
+   * identity kinds. Candidates the graph cannot resolve fall through to the
+   * engine's built-in sender heuristics. When the graph service is absent the
+   * hook resolves nothing.
+   */
+  async buildKnowledgeGraphIdentityHook(candidates) {
+    const kg = resolveKnowledgeGraphService(this.runtime);
+    if (!kg) return () => null;
+    const store = kg.getEntityStore();
+    const resolved = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const senderEmail = normalizeSenderEmail(candidate);
+      if (!senderEmail) continue;
+      const matches = await store.resolve({
+        identity: { platform: "email", handle: senderEmail }
+      });
+      const best = matches[0];
+      if (!best) continue;
+      resolved.set(candidate.id, entityToCurationIdentity(best));
+    }
+    return (candidate) => resolved.get(candidate.id) ?? null;
+  }
+  /**
+   * Read persisted triage entries, optionally filtered by classification.
+   * Backs the INBOX action's `search`/`list` reads over the triage queue.
+   */
+  async search(opts = {}) {
+    if (opts.classification) {
+      return this.repository.getByClassification(opts.classification, {
+        ...opts.limit !== void 0 ? { limit: opts.limit } : {},
+        ...opts.unresolvedOnly !== void 0 ? { unresolvedOnly: opts.unresolvedOnly } : {}
+      });
+    }
+    return this.repository.getUnresolved(
+      opts.limit !== void 0 ? { limit: opts.limit } : void 0
+    );
+  }
+  /** Unresolved triage queue (urgency-ordered). */
+  async list(limit) {
+    return this.repository.getUnresolved(
+      limit !== void 0 ? { limit } : void 0
+    );
+  }
+  /** Non-ignored triage entries created since `sinceIso`, urgency-ordered. */
+  async digest(sinceIso) {
+    return this.repository.getRecentForDigest(sinceIso);
+  }
+  /** Mark a triage entry resolved (optionally recording the sent draft). */
+  async resolve(id, opts) {
+    await this.repository.markResolved(id, opts);
+  }
+}
+export {
+  InboxService
+};
+//# sourceMappingURL=service.js.map

package/dist/inbox/service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/inbox/service.ts"],"sourcesContent":["/**\n * InboxService — the inbox triage back-end.\n *\n * Standalone successor to the inbox-domain logic that lived in PA's\n * `service-mixin-inbox` + `inbox/` modules. It holds its own runtime and\n * {@link InboxRepository} (raw SQL over the `app_inbox.life_inbox_triage_*`\n * tables PA still registers), classifies inbound messages with the LLM, and\n * answers the triage-queue reads the INBOX action and inboxTriage provider need.\n * It carries no dependency on `@elizaos/plugin-personal-assistant`.\n *\n * NOT here (delegated / left in PA, by design):\n *   - `getInbox` / `markInboxEntryRead` — the cached cross-channel inbox that\n *     backs `GET /api/lifeops/inbox`. It is coupled to PA's `LifeOpsRepository`\n *     inbox cache, LLM priority scoring, Gmail/X connector sources, and the\n *     app-state store, so it remains a PA service method (the route shape stays\n *     byte-identical). InboxService takes the inbound feed as input instead of\n *     pulling connectors itself.\n */\n\nimport { resolveKnowledgeGraphService } from \"@elizaos/agent/services/knowledge-graph/service\";\nimport type { IAgentRuntime, NotificationService } from \"@elizaos/core\";\nimport { logger, ServiceType } from \"@elizaos/core\";\nimport type { EntityResolveCandidate } from \"@elizaos/shared\";\nimport { loadInboxTriageConfig } from \"./config.js\";\nimport {\n  type CurationDecision,\n  curateEmailCandidates,\n  type EmailCurationCandidate,\n  type EmailCurationIdentityHook,\n  type EmailCurationOutput,\n  type EmailCurationPolicy,\n  type EmailCurationPolicyHook,\n  type EmailCurationResolvedIdentity,\n} from \"./email-curation.js\";\nimport { InboxRepository } from \"./repository.js\";\nimport { classifyMessages } from \"./triage-classifier.js\";\nimport type {\n  InboundMessage,\n  InboxTriageConfig,\n  TriageClassification,\n  TriageEntry,\n} from \"./types.js\";\n\n/** Lower-cased, angle-bracket-stripped sender email, or null. */\nfunction normalizeSenderEmail(\n  candidate: EmailCurationCandidate,\n): string | null {\n  const raw = candidate.fromEmail ?? candidate.from;\n  if (!raw) return null;\n  const angle = raw.match(/<([^>]+)>/);\n  const value = (angle?.[1] ?? raw).trim().toLowerCase();\n  const email = value.match(/[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,}/i);\n  return email?.[0]?.toLowerCase() ?? null;\n}\n\n/**\n * Map a resolved knowledge-graph entity onto the engine's identity contract.\n * A `vip`-tagged entity is a VIP; any other graph person/org is a known\n * sender. Both block bulk delete (the graph deliberately tracked them).\n */\nfunction entityToCurationIdentity(\n  candidate: EntityResolveCandidate,\n): EmailCurationResolvedIdentity {\n  const { entity } = candidate;\n  const isVip = entity.tags.some((tag) => tag.toLowerCase() === \"vip\");\n  return {\n    kind: isVip ? \"vip\" : \"known_person\",\n    label: entity.preferredName,\n    matchedBy: [\"knowledge_graph.identity.email\"],\n    blockDelete: true,\n    personId: entity.entityId,\n  };\n}\n\n/** Project a normalized inbound message onto the engine's candidate shape. */\nfunction toCurationCandidate(message: InboundMessage): EmailCurationCandidate {\n  return {\n    id: message.id,\n    ...(message.threadId ? { threadId: message.threadId } : {}),\n    subject: message.channelName,\n    snippet: message.snippet,\n    from: message.senderName,\n    ...(message.senderEmail ? { fromEmail: message.senderEmail } : {}),\n    bodyText: message.text,\n    receivedAt: new Date(message.timestamp).toISOString(),\n  };\n}\n\nexport interface TriageOptions {\n  /** Override the loaded triage config (priority senders/channels, rules). */\n  config?: InboxTriageConfig;\n  /** Owner context string injected into the classifier prompt. */\n  ownerContext?: string;\n  /** How many past owner-corrected examples to few-shot the classifier with. */\n  exampleLimit?: number;\n  /** Skip persistence and only return the classification (default false). */\n  classifyOnly?: boolean;\n}\n\nexport interface TriagedMessage {\n  message: InboundMessage;\n  classification: TriageClassification;\n  urgency: \"low\" | \"medium\" | \"high\";\n  confidence: number;\n  reasoning: string;\n  suggestedResponse?: string;\n  /** The persisted triage entry, unless `classifyOnly` was set. */\n  entry?: TriageEntry;\n}\n\nexport interface TriageRunResult {\n  triaged: TriagedMessage[];\n}\n\nexport interface SearchOptions {\n  classification?: TriageClassification;\n  limit?: number;\n  unresolvedOnly?: boolean;\n}\n\nexport interface CurateOptions {\n  /**\n   * Identity resolver. Defaults to a hook backed by the runtime\n   * {@link resolveKnowledgeGraphService | knowledge-graph service}, which\n   * resolves the sender's entity from the runtime graph. Injectable as a test\n   * seam and to let callers override the identity source.\n   */\n  identityHook?: EmailCurationIdentityHook;\n  /**\n   * Policy hook applied after the engine's provisional decision. Defaults to a\n   * no-op (the engine's built-in `DEFAULT_POLICY` thresholds and delete\n   * blockers still apply). No PA-owned policy store is reachable from the\n   * inbox plugin without importing PA, so there is no default policy source\n   * beyond the engine's own defaults.\n   */\n  policyHook?: EmailCurationPolicyHook;\n  /** Static policy overrides merged onto the engine defaults. */\n  policy?: EmailCurationPolicy;\n  /** Override the curation timestamp (defaults to engine `now`). */\n  now?: string;\n}\n\n/** The curation decision attached to a triaged message. */\nexport interface CuratedMessage extends TriagedMessage {\n  curation: CurationDecision;\n}\n\nexport interface TriageWithCurationResult {\n  triaged: CuratedMessage[];\n  curation: EmailCurationOutput;\n}\n\n/**\n * The triage / search / list back-end for the inbox domain. One instance per\n * call is fine — the repository is a thin raw-SQL wrapper over the runtime DB.\n */\nexport class InboxService {\n  private readonly repository: InboxRepository;\n\n  constructor(private readonly runtime: IAgentRuntime) {\n    this.repository = new InboxRepository(runtime);\n  }\n\n  getRepository(): InboxRepository {\n    return this.repository;\n  }\n\n  /**\n   * Classify a batch of inbound messages and (unless `classifyOnly`) persist\n   * one triage entry per message. Returns the per-message decision in input\n   * order. Messages already triaged by `source_message_id` are skipped so a\n   * re-run does not double-store.\n   */\n  async triage(\n    messages: InboundMessage[],\n    opts: TriageOptions = {},\n  ): Promise<TriageRunResult> {\n    if (messages.length === 0) return { triaged: [] };\n\n    const config = opts.config ?? loadInboxTriageConfig();\n    const examples = opts.classifyOnly\n      ? []\n      : await this.repository.getExamples(opts.exampleLimit ?? 10);\n\n    const results = await classifyMessages(this.runtime, messages, {\n      config,\n      examples,\n      ...(opts.ownerContext ? { ownerContext: opts.ownerContext } : {}),\n    });\n\n    const triaged: TriagedMessage[] = [];\n    for (let i = 0; i < messages.length; i += 1) {\n      const message = messages[i];\n      const result = results[i];\n      if (!message || !result) continue;\n\n      const triagedMessage: TriagedMessage = {\n        message,\n        classification: result.classification,\n        urgency: result.urgency,\n        confidence: result.confidence,\n        reasoning: result.reasoning,\n        ...(result.suggestedResponse\n          ? { suggestedResponse: result.suggestedResponse }\n          : {}),\n      };\n\n      if (!opts.classifyOnly) {\n        const existing = message.id\n          ? await this.repository.getBySourceMessageId(message.id)\n          : null;\n        if (existing) {\n          triagedMessage.entry = existing;\n        } else {\n          const stored = await this.repository.storeTriage({\n            source: message.source,\n            ...(message.roomId ? { sourceRoomId: message.roomId } : {}),\n            ...(message.entityId ? { sourceEntityId: message.entityId } : {}),\n            ...(message.id ? { sourceMessageId: message.id } : {}),\n            channelName: message.channelName,\n            channelType: message.channelType,\n            ...(message.deepLink ? { deepLink: message.deepLink } : {}),\n            classification: result.classification,\n            urgency: result.urgency,\n            confidence: result.confidence,\n            snippet: message.snippet,\n            ...(message.senderName ? { senderName: message.senderName } : {}),\n            ...(message.threadMessages && message.threadMessages.length > 0\n              ? { threadContext: message.threadMessages }\n              : {}),\n            ...(result.reasoning ? { triageReasoning: result.reasoning } : {}),\n            ...(result.suggestedResponse\n              ? { suggestedResponse: result.suggestedResponse }\n              : {}),\n          });\n          triagedMessage.entry = stored;\n          // A newly-triaged message the user needs to act on is a home-screen\n          // attention moment. Fire once per new entry (groupKey collapses) only\n          // for the act-now classifications, so the inbox doesn't spam the\n          // notification rail with every \"info\"/\"notify\" item (those stay\n          // visible in the inbox view).\n          this.notifyAttention(stored);\n        }\n      }\n\n      triaged.push(triagedMessage);\n    }\n\n    return { triaged };\n  }\n\n  /**\n   * Surface an act-now triage entry (`urgent` / `needs_reply`) on the home\n   * notification rail. Best-effort: a runtime with no NotificationService (a\n   * headless/test runtime) is a no-op. `info`/`notify`/`ignore` stay in the\n   * inbox view without pushing a notification.\n   */\n  private notifyAttention(entry: TriageEntry): void {\n    const isUrgent = entry.classification === \"urgent\";\n    if (!isUrgent && entry.classification !== \"needs_reply\") return;\n\n    const who = entry.senderName ? ` from ${entry.senderName}` : \"\";\n    this.runtime\n      .getService<NotificationService>(ServiceType.NOTIFICATION)\n      ?.notify({\n        title: isUrgent\n          ? `Urgent message${who}`\n          : `Message${who} needs a reply`,\n        body: entry.snippet,\n        category: \"message\",\n        priority: isUrgent ? \"urgent\" : \"high\",\n        source: \"inbox\",\n        groupKey: `inbox:${entry.id}`,\n        deepLink: entry.deepLink ?? \"/inbox\",\n        data: {\n          triageEntryId: entry.id,\n          classification: entry.classification,\n          channelName: entry.channelName,\n        },\n      })\n      .catch((error: unknown) => {\n        logger.debug({ src: \"inbox\", error }, \"Triage notify failed\");\n      });\n  }\n\n  /**\n   * Run the pure email-curation engine over a batch of inbound messages and\n   * return the per-candidate decision (save / archive / delete / review with\n   * evidence, citations, and a bulk-review block).\n   *\n   * This is the richer decision path that complements {@link triage}: triage\n   * answers \"how urgent is this and should I reply\", curation answers \"what\n   * should happen to this message in the owner's mailbox\". It does not persist\n   * anything — callers decide what to do with the suggested action.\n   *\n   * The identity hook is backed by the runtime knowledge-graph service so the\n   * sender's entity (VIP / known person / service) feeds the engine's\n   * delete-blockers. Both hooks are injectable as a test seam.\n   */\n  async curate(\n    messages: InboundMessage[],\n    opts: CurateOptions = {},\n  ): Promise<EmailCurationOutput> {\n    const candidates = messages.map((message) => toCurationCandidate(message));\n    // The engine's identity hook is synchronous, but the knowledge-graph read\n    // is async, so we pre-resolve every candidate's identity here and hand the\n    // engine a synchronous lookup over that map. An explicitly injected hook\n    // wins (test seam / caller override).\n    const identityHook =\n      opts.identityHook ??\n      (await this.buildKnowledgeGraphIdentityHook(candidates));\n    return curateEmailCandidates({\n      candidates,\n      identityHook,\n      ...(opts.policyHook ? { policyHook: opts.policyHook } : {}),\n      ...(opts.policy ? { policy: opts.policy } : {}),\n      ...(opts.now ? { now: opts.now } : {}),\n    });\n  }\n\n  /**\n   * Triage a batch, then attach a curation decision to each message in the\n   * same input order. Triage behavior is unchanged (the existing\n   * classification + persistence still runs); curation is additive.\n   */\n  async triageWithCuration(\n    messages: InboundMessage[],\n    opts: TriageOptions & CurateOptions = {},\n  ): Promise<TriageWithCurationResult> {\n    const { identityHook, policyHook, policy, now, ...triageOpts } = opts;\n    const triageResult = await this.triage(messages, triageOpts);\n    const curation = await this.curate(messages, {\n      ...(identityHook ? { identityHook } : {}),\n      ...(policyHook ? { policyHook } : {}),\n      ...(policy ? { policy } : {}),\n      ...(now ? { now } : {}),\n    });\n\n    const decisionByCandidateId = new Map(\n      curation.decisions.flatMap((decision) =>\n        decision.canonicalMessageIds.map((id) => [id, decision] as const),\n      ),\n    );\n\n    const triaged: CuratedMessage[] = triageResult.triaged.flatMap(\n      (triagedMessage) => {\n        const decision = decisionByCandidateId.get(triagedMessage.message.id);\n        if (!decision) return [];\n        return [{ ...triagedMessage, curation: decision }];\n      },\n    );\n\n    return { triaged, curation };\n  }\n\n  /**\n   * Build an {@link EmailCurationIdentityHook} backed by the runtime\n   * knowledge-graph service. Pre-resolves every candidate's sender against the\n   * entity graph (the engine hook itself must be synchronous, so the async\n   * graph reads happen here) and maps the resolved entity onto the engine's\n   * identity kinds. Candidates the graph cannot resolve fall through to the\n   * engine's built-in sender heuristics. When the graph service is absent the\n   * hook resolves nothing.\n   */\n  private async buildKnowledgeGraphIdentityHook(\n    candidates: readonly EmailCurationCandidate[],\n  ): Promise<EmailCurationIdentityHook> {\n    const kg = resolveKnowledgeGraphService(this.runtime);\n    if (!kg) return () => null;\n    const store = kg.getEntityStore();\n\n    const resolved = new Map<string, EmailCurationResolvedIdentity>();\n    for (const candidate of candidates) {\n      const senderEmail = normalizeSenderEmail(candidate);\n      if (!senderEmail) continue;\n      const matches = await store.resolve({\n        identity: { platform: \"email\", handle: senderEmail },\n      });\n      const best = matches[0];\n      if (!best) continue;\n      resolved.set(candidate.id, entityToCurationIdentity(best));\n    }\n\n    return (candidate) => resolved.get(candidate.id) ?? null;\n  }\n\n  /**\n   * Read persisted triage entries, optionally filtered by classification.\n   * Backs the INBOX action's `search`/`list` reads over the triage queue.\n   */\n  async search(opts: SearchOptions = {}): Promise<TriageEntry[]> {\n    if (opts.classification) {\n      return this.repository.getByClassification(opts.classification, {\n        ...(opts.limit !== undefined ? { limit: opts.limit } : {}),\n        ...(opts.unresolvedOnly !== undefined\n          ? { unresolvedOnly: opts.unresolvedOnly }\n          : {}),\n      });\n    }\n    return this.repository.getUnresolved(\n      opts.limit !== undefined ? { limit: opts.limit } : undefined,\n    );\n  }\n\n  /** Unresolved triage queue (urgency-ordered). */\n  async list(limit?: number): Promise<TriageEntry[]> {\n    return this.repository.getUnresolved(\n      limit !== undefined ? { limit } : undefined,\n    );\n  }\n\n  /** Non-ignored triage entries created since `sinceIso`, urgency-ordered. */\n  async digest(sinceIso: string): Promise<TriageEntry[]> {\n    return this.repository.getRecentForDigest(sinceIso);\n  }\n\n  /** Mark a triage entry resolved (optionally recording the sent draft). */\n  async resolve(\n    id: string,\n    opts?: { draftResponse?: string; autoReplied?: boolean },\n  ): Promise<void> {\n    await this.repository.markResolved(id, opts);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/inbox/triage-classifier.d.ts

@@ -0,0 +1,28 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import type { InboundMessage, InboxTriageConfig, TriageExample, TriageResult } from "./types.js";
+export declare class InboxTriageClassificationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Classify a batch of messages using the LLM. Returns one TriageResult per
+ * input message, in the same order.
+ */
+export declare function classifyMessages(runtime: IAgentRuntime, messages: InboundMessage[], opts: {
+    config?: InboxTriageConfig;
+    examples?: TriageExample[];
+    ownerContext?: string;
+}): Promise<TriageResult[]>;
+/**
+ * Static classification instructions for the inbox-triage task. Exposed as the
+ * optimizable baseline so {@link resolveOptimizedPromptForRuntime} can swap in a
+ * GEPA-optimized `inbox_triage` artifact when one is registered (#8795). The
+ * dynamic owner context / examples / messages are scaffolded around it below.
+ */
+export declare const INBOX_TRIAGE_INSTRUCTIONS: string;
+export declare function buildTriagePrompt(messages: InboundMessage[], opts: {
+    config?: InboxTriageConfig;
+    examples?: TriageExample[];
+    ownerContext?: string;
+    runtime?: IAgentRuntime;
+}): string;
+//# sourceMappingURL=triage-classifier.d.ts.map

package/dist/inbox/triage-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-classifier.d.ts","sourceRoot":"","sources":["../../src/inbox/triage-classifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAQnD,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EAEjB,aAAa,EACb,YAAY,EACb,MAAM,YAAY,CAAC;AAMpB,qBAAa,8BAA+B,SAAQ,KAAK;gBAC3C,OAAO,EAAE,MAAM;CAI5B;AAaD;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,cAAc,EAAE,EAC1B,IAAI,EAAE;IACJ,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GACA,OAAO,CAAC,YAAY,EAAE,CAAC,CAczB;AAoCD;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,QAc1B,CAAC;AAEb,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,cAAc,EAAE,EAC1B,IAAI,EAAE;IACJ,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB,GACA,MAAM,CA+FR"}

package/dist/inbox/triage-classifier.js

@@ -0,0 +1,306 @@
+import {
+  logger,
+  ModelType,
+  parseJsonModelRecord,
+  resolveOptimizedPromptForRuntime,
+  runWithTrajectoryContext
+} from "@elizaos/core";
+class InboxTriageClassificationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InboxTriageClassificationError";
+  }
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function formatPromptScalar(value, maxLength = 600) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return String(value).replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+async function classifyMessages(runtime, messages, opts) {
+  if (messages.length === 0) return [];
+  const results = [];
+  const batchSize = 10;
+  for (let i = 0; i < messages.length; i += batchSize) {
+    const batch = messages.slice(i, i + batchSize);
+    const batchResults = await classifyBatch(runtime, batch, opts);
+    results.push(...batchResults);
+  }
+  return results;
+}
+async function classifyBatch(runtime, messages, opts) {
+  const prompt = buildTriagePrompt(messages, { ...opts, runtime });
+  let rawResponse = "";
+  try {
+    const result = await runWithTrajectoryContext(
+      { purpose: "inbox_triage" },
+      () => runtime.useModel(ModelType.TEXT_SMALL, { prompt })
+    );
+    rawResponse = typeof result === "string" ? result : "";
+  } catch (error) {
+    logger.warn(
+      {
+        src: "inbox-classifier",
+        error: error instanceof Error ? error.message : String(error)
+      },
+      "[InboxTriageClassifier] LLM classification failed"
+    );
+    throw new InboxTriageClassificationError(
+      "Inbox classification model call failed."
+    );
+  }
+  return parseTriageResults(rawResponse, messages.length);
+}
+const INBOX_TRIAGE_INSTRUCTIONS = [
+  "Classify each message into one of these categories:",
+  "",
+  "- ignore: spam, irrelevant, automated notifications, bot messages, or general chat that needs no attention",
+  "- info: informational updates the owner might want to see but doesn't need to act on",
+  "- notify: important information the owner should see, but no response is needed",
+  "- needs_reply: someone is asking a question or expects a response from the owner",
+  "- urgent: time-sensitive, critical, or from a priority contact \u2014 needs immediate attention",
+  "",
+  "For each message, also provide:",
+  "- urgency: low / medium / high",
+  "- confidence: 0.0 to 1.0 (how sure you are about this classification)",
+  "- reasoning: brief explanation",
+  "- suggestedResponse: (optional) a brief draft response if classification is needs_reply or urgent"
+].join("\n");
+function buildTriagePrompt(messages, opts) {
+  const sections = [];
+  const instructions = opts.runtime ? resolveOptimizedPromptForRuntime(
+    opts.runtime,
+    "inbox_triage",
+    INBOX_TRIAGE_INSTRUCTIONS
+  ) : INBOX_TRIAGE_INSTRUCTIONS;
+  sections.push(instructions);
+  if (opts.ownerContext) {
+    sections.push("", "Owner context:", opts.ownerContext);
+  }
+  const config = opts.config;
+  if (config?.prioritySenders?.length) {
+    sections.push("", "Priority senders (treat as higher urgency):");
+    for (const [index, sender] of config.prioritySenders.entries()) {
+      sections.push(`prioritySenders[${index}]: ${formatPromptScalar(sender)}`);
+    }
+  }
+  if (config?.priorityChannels?.length) {
+    sections.push("", "Priority channels:");
+    for (const [index, channel] of config.priorityChannels.entries()) {
+      sections.push(
+        `priorityChannels[${index}]: ${formatPromptScalar(channel)}`
+      );
+    }
+  }
+  if (opts.examples && opts.examples.length > 0) {
+    sections.push("", "Examples from past triage decisions:");
+    for (const [index, ex] of opts.examples.slice(0, 5).entries()) {
+      sections.push(
+        `examples[${index}]:`,
+        `  source: ${formatPromptScalar(ex.source, 120)}`,
+        `  snippet: ${formatPromptScalar(ex.snippet, 160)}`,
+        `  classification: ${ex.classification}`,
+        `  ownerClassification: ${ex.ownerClassification ?? ""}`
+      );
+    }
+  }
+  sections.push("", "Messages to classify:", "");
+  for (const [index, msg] of messages.entries()) {
+    const gmailHints = [];
+    if (msg.gmailIsImportant) gmailHints.push("Gmail-marked-important");
+    if (msg.gmailLikelyReplyNeeded)
+      gmailHints.push("Gmail-likely-reply-needed");
+    sections.push(
+      `messages[${index}]:`,
+      `  source: ${formatPromptScalar(msg.source, 120)}`,
+      `  channelName: ${formatPromptScalar(msg.channelName, 160)}`,
+      `  channelType: ${msg.channelType}`,
+      `  senderName: ${formatPromptScalar(msg.senderName, 160)}`
+    );
+    for (const [hintIndex, hint] of gmailHints.entries()) {
+      sections.push(`  hints[${hintIndex}]: ${hint}`);
+    }
+    sections.push(`  text: ${formatPromptScalar(msg.text, 500)}`);
+    if (msg.threadMessages && msg.threadMessages.length > 0) {
+      for (const [threadIndex, threadMessage] of msg.threadMessages.slice(-5).entries()) {
+        sections.push(
+          `  threadMessages[${threadIndex}]: ${formatPromptScalar(threadMessage, 240)}`
+        );
+      }
+    }
+    sections.push("");
+  }
+  sections.push(
+    "Return JSON only as a single object with one results array entry per message in the same order.",
+    "Use this exact shape:",
+    '{"results":[{"classification":"ignore|info|notify|needs_reply|urgent","urgency":"low|medium|high","confidence":0.0,"reasoning":"brief explanation","suggestedResponse":null}]}',
+    // The `a|b|c` placeholders above list the allowed values — they are NOT
+    // literal output. Smaller/local models otherwise echo the pipe string
+    // ("urgent|ignore"), which fails strict validation. Be explicit.
+    'For "classification" output exactly one of: ignore, info, notify, needs_reply, urgent.',
+    'For "urgency" output exactly one of: low, medium, high.',
+    'Choose a single value per field \u2014 never output the "|" character or more than one option.',
+    "suggestedResponse may be a brief draft response when useful, otherwise null.",
+    "",
+    "No prose, markdown, code fences, or <think>."
+  );
+  return sections.join("\n");
+}
+const TRIAGE_CODE_FENCE_PATTERN = /^\s*```(?:json|json5)?\s*\r?\n?([\s\S]*?)\r?\n?```\s*$/i;
+function parseTriageJsonArray(raw) {
+  let candidate = raw.trim();
+  if (candidate.length === 0) {
+    throw new InboxTriageClassificationError(
+      "Inbox classification returned an empty response."
+    );
+  }
+  const thinkEnd = candidate.indexOf("</think>");
+  if (candidate.startsWith("<think>") && thinkEnd !== -1) {
+    candidate = candidate.slice(thinkEnd + "</think>".length).trim();
+  }
+  const fenced = candidate.match(TRIAGE_CODE_FENCE_PATTERN);
+  if (fenced) {
+    candidate = (fenced[1] ?? "").trim();
+  }
+  if (!candidate.startsWith("[")) {
+    throw new InboxTriageClassificationError(
+      "Inbox classification did not return a JSON array."
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(candidate);
+  } catch (error) {
+    logger.warn(
+      { src: "inbox-classifier", error: String(error) },
+      "[InboxTriageClassifier] failed to parse LLM classification JSON"
+    );
+    throw new InboxTriageClassificationError(
+      "Inbox classification JSON parsing failed."
+    );
+  }
+  if (!Array.isArray(parsed)) {
+    throw new InboxTriageClassificationError(
+      "Inbox classification did not return a JSON array."
+    );
+  }
+  return parsed;
+}
+function asStructuredArray(value) {
+  return Array.isArray(value) ? value : null;
+}
+function parseTriageJsonObjectArray(raw) {
+  const parsed = parseJsonModelRecord(raw);
+  if (!parsed) {
+    return null;
+  }
+  const directArray = asStructuredArray(parsed.results) ?? asStructuredArray(parsed.messages) ?? asStructuredArray(parsed.items) ?? asStructuredArray(parsed.classifications);
+  if (directArray) {
+    return directArray;
+  }
+  const classifications = asStructuredArray(parsed.classification);
+  if (!classifications) {
+    return null;
+  }
+  const urgencies = asStructuredArray(parsed.urgency) ?? [];
+  const confidences = asStructuredArray(parsed.confidence) ?? [];
+  const reasonings = asStructuredArray(parsed.reasoning) ?? [];
+  const suggestedResponses = asStructuredArray(parsed.suggestedResponse) ?? asStructuredArray(parsed.suggested_response) ?? [];
+  return classifications.map((classification, index) => ({
+    classification,
+    urgency: urgencies[index],
+    confidence: confidences[index],
+    reasoning: reasonings[index],
+    suggestedResponse: suggestedResponses[index]
+  }));
+}
+function parseTriageStructuredArray(raw) {
+  const jsonParsed = parseTriageJsonObjectArray(raw);
+  if (jsonParsed) {
+    return jsonParsed;
+  }
+  return parseTriageJsonArray(raw);
+}
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.toLowerCase() === "null") {
+    return void 0;
+  }
+  return trimmed;
+}
+function parseTriageResults(raw, expectedCount) {
+  const parsed = parseTriageStructuredArray(raw);
+  const results = [];
+  for (let i = 0; i < expectedCount; i++) {
+    const item = parsed[i];
+    if (!isRecord(item)) {
+      throw new InboxTriageClassificationError(
+        "Inbox classification omitted one or more messages."
+      );
+    }
+    const classification = validClassification(item.classification);
+    const urgency = validUrgency(item.urgency);
+    const confidence = validConfidence(item.confidence);
+    if (!classification || !urgency || confidence === null) {
+      throw new InboxTriageClassificationError(
+        "Inbox classification returned invalid structured fields."
+      );
+    }
+    results.push({
+      classification,
+      urgency,
+      confidence,
+      reasoning: normalizeOptionalString(item.reasoning) ?? "",
+      suggestedResponse: normalizeOptionalString(
+        item.suggestedResponse ?? item.suggested_response
+      )
+    });
+  }
+  return results;
+}
+const VALID_CLASSIFICATIONS = /* @__PURE__ */ new Set([
+  "ignore",
+  "info",
+  "notify",
+  "needs_reply",
+  "urgent"
+]);
+const VALID_URGENCIES = /* @__PURE__ */ new Set(["low", "medium", "high"]);
+function validClassification(v) {
+  if (typeof v === "string") {
+    const normalized = v.trim().toLowerCase();
+    if (VALID_CLASSIFICATIONS.has(normalized)) {
+      return normalized;
+    }
+  }
+  return null;
+}
+function validUrgency(v) {
+  if (typeof v === "string") {
+    const normalized = v.trim().toLowerCase();
+    if (VALID_URGENCIES.has(normalized)) {
+      return normalized;
+    }
+  }
+  return null;
+}
+function validConfidence(v) {
+  const numeric = typeof v === "string" && v.trim().length > 0 ? Number(v.trim()) : v;
+  if (typeof numeric === "number" && Number.isFinite(numeric) && numeric >= 0 && numeric <= 1) {
+    return numeric;
+  }
+  return null;
+}
+export {
+  INBOX_TRIAGE_INSTRUCTIONS,
+  InboxTriageClassificationError,
+  buildTriagePrompt,
+  classifyMessages
+};
+//# sourceMappingURL=triage-classifier.js.map