@skaile/workspaces 6.11.0 → 6.12.0

package/dist/channels/index.js

@@ -1,5 +1,5 @@
-import { mentionsAgent } from '../chunk-F2IBDVBP.js';
-export { CHANNEL_PLATFORMS, makeConversationKey, makeQuestionCard, markdownToTeamsText, mentionsAgent, normalizeMentions, parseConversationKey, teamsFormatConverter } from '../chunk-F2IBDVBP.js';
+import { mentionsAgent } from '../chunk-VHRGCLCR.js';
+export { CHANNEL_PLATFORMS, makeConversationKey, makeQuestionCard, markdownToTeamsText, mentionsAgent, normalizeMentions, parseConversationKey, teamsFormatConverter } from '../chunk-VHRGCLCR.js';
 import '../chunk-NSBPE2FW.js';
 import { ulid } from 'ulid';
 
@@ -10,6 +10,100 @@ var consoleChannelLogger = {
   error: (m, e, d) => console.error(`[channels] ${m}`, e ?? "", d ?? "")
 };
 
+// channels/src/context-batch.ts
+var DEFAULT_FLUSH_AFTER_MS = 3e4;
+var DEFAULT_MAX_BATCH = 20;
+var DEFAULT_HOURLY_CAP = 200;
+var HOUR_MS = 36e5;
+var ContextBatcher = class {
+  flushAfterMs;
+  maxBatch;
+  hourlyCap;
+  now;
+  onDue;
+  logger;
+  conversationKey;
+  pending = [];
+  timer;
+  windowStart = Number.NEGATIVE_INFINITY;
+  acceptedInWindow = 0;
+  droppedInWindow = 0;
+  constructor(opts) {
+    this.flushAfterMs = opts.options?.flushAfterMs ?? DEFAULT_FLUSH_AFTER_MS;
+    this.maxBatch = opts.options?.maxBatch ?? DEFAULT_MAX_BATCH;
+    this.hourlyCap = opts.options?.hourlyCap ?? DEFAULT_HOURLY_CAP;
+    this.now = opts.now;
+    this.onDue = opts.onDue;
+    this.logger = opts.logger;
+    this.conversationKey = opts.conversationKey;
+  }
+  /** Messages waiting for the next flush. */
+  get size() {
+    return this.pending.length;
+  }
+  /** Buffers `msg` unless the hourly cap is spent. `"full"` means flush now. */
+  add(msg) {
+    this.rollWindow();
+    if (this.acceptedInWindow >= this.hourlyCap) {
+      this.droppedInWindow += 1;
+      if (this.droppedInWindow === 1) {
+        this.logger.warn(
+          "read-along context cap reached; dropping context for the rest of the hour",
+          {
+            conversationKey: this.conversationKey,
+            hourlyCap: this.hourlyCap
+          }
+        );
+      }
+      return "dropped";
+    }
+    this.acceptedInWindow += 1;
+    this.pending.push(msg);
+    if (this.pending.length >= this.maxBatch) return "full";
+    if (this.timer === void 0) {
+      this.timer = setTimeout(() => {
+        this.timer = void 0;
+        this.onDue();
+      }, this.flushAfterMs);
+    }
+    return "buffered";
+  }
+  /** Drains the pending batch (possibly empty) and cancels its timer. */
+  take() {
+    this.clearTimer();
+    const batch = this.pending;
+    this.pending = [];
+    return batch;
+  }
+  /** Cancels the timer and logs any drops still unreported. Pending messages are left to `take()`. */
+  dispose() {
+    this.clearTimer();
+    this.reportDropped();
+  }
+  rollWindow() {
+    const now = this.now();
+    if (now - this.windowStart < HOUR_MS) return;
+    this.reportDropped();
+    this.windowStart = now;
+    this.acceptedInWindow = 0;
+    this.droppedInWindow = 0;
+  }
+  reportDropped() {
+    if (this.droppedInWindow === 0) return;
+    this.logger.warn("read-along context dropped over the hourly cap", {
+      conversationKey: this.conversationKey,
+      dropped: this.droppedInWindow,
+      hourlyCap: this.hourlyCap
+    });
+    this.droppedInWindow = 0;
+  }
+  clearTimer() {
+    if (this.timer === void 0) return;
+    clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+};
+
 // channels/src/dedupe.ts
 var TtlDedupeStore = class {
   ttlMs;
@@ -434,6 +528,9 @@ var ChunkedMessageStream = class {
 
 // channels/src/egress/output-mirror.ts
 var TYPING_THROTTLE_MS = 3e3;
+function endsTurn(e) {
+  return e.type === "finished" || e.type === "status" && e.phase === "idle";
+}
 var OutputMirror = class {
   opts;
   turn;
@@ -463,6 +560,9 @@ var OutputMirror = class {
       case "error":
         this.postAside({ markdown: e.message, kind: "error" });
         break;
+      case "status":
+        if (endsTurn(e)) this.finishTurn();
+        break;
       case "typing":
         this.onTyping(e.isTyping);
         break;
@@ -635,6 +735,7 @@ function inboundMessageRef(ch) {
   };
 }
 var textOf = (msg) => msg.payload.type === "prompt" ? msg.payload.prompt : "";
+var isMentioned = (msg, ch) => ch.mentioned ?? mentionsAgent(msg.meta?.mentions ?? []);
 function withSenderId(msg, senderId) {
   return { ...msg, meta: { ...msg.meta, senderId } };
 }
@@ -831,10 +932,10 @@ var ChannelEngine = class {
       tenantId: ch.tenantId
     };
     const host = await ports.identity.resolveActor(actor);
+    const mentioned = isMentioned(evt, ch);
     let binding = await ports.bindings.get(ch.conversationKey);
     if (!binding?.enabled) {
-      const mentions = evt.meta?.mentions ?? [];
-      if (!mentionsAgent(mentions) || !ports.session.createSession) return;
+      if (!mentioned || !ports.session.createSession) return;
       if (host === null && this.unmappedActorPolicy === "reject") {
         await this.postRejectNotice(adapter, ch, actor);
         return;
@@ -851,13 +952,17 @@ var ChannelEngine = class {
         sessionId: ref.sessionId,
         platform: ch.platform,
         tenantId: ch.tenantId,
-        mirrorMode: "agent-only",
+        mirrorMode: this.opts.lazyBindMirrorMode ?? "agent-only",
         enabled: true,
         createdBy: host?.id ?? `external:${actor.externalId}`,
         createdAt: new Date(this.now()).toISOString()
       };
       await ports.bindings.put(binding);
     }
+    if (!mentioned && ports.session.appendContext) {
+      await this.appendAsContext(binding, evt, actor, host);
+      return;
+    }
     let delivery = evt;
     if (host === null) {
       if (this.unmappedActorPolicy === "reject") {
@@ -870,11 +975,41 @@ var ChannelEngine = class {
     }
     this.ensureMirror(binding);
     const state = this.stateFor(binding);
+    await this.flushContext(state);
     state.delivered.set(textOf(delivery), true);
     state.chatInitiated = true;
     await ports.session.deliver(binding, delivery);
     this.armPlaceholder(binding, state);
   }
+  /**
+   * Read-along: queues a message that did not mention the bot as session
+   * context. It never starts a turn, so an unmapped actor needs no reject
+   * notice: the message is framed as untrusted and carries no senderId.
+   */
+  async appendAsContext(binding, evt, actor, host) {
+    if (textOf(evt).trim() === "") return;
+    const msg = host === null ? frameAsExternal(evt, actor) : withSenderId(evt, host.id);
+    this.ensureMirror(binding);
+    const state = this.stateFor(binding);
+    const added = state.context.add(msg);
+    if (added === "dropped") return;
+    state.delivered.set(textOf(msg), true);
+    if (added === "full") await this.flushContext(state);
+  }
+  /** Hands the pending read-along batch to `SessionPort.appendContext`; logs, never throws. */
+  async flushContext(state) {
+    const appendContext = this.opts.ports.session.appendContext;
+    const batch = state.context.take();
+    if (batch.length === 0 || !appendContext) return;
+    try {
+      await appendContext.call(this.opts.ports.session, state.binding, batch);
+    } catch (err) {
+      this.logger.error("appendContext failed; read-along context lost", err, {
+        conversationKey: state.binding.conversationKey,
+        messages: batch.length
+      });
+    }
+  }
   /** "Teams: <snippet>" — title for a lazily-created thread session. */
   sessionTitle(ch, text) {
     const snippet = text.trim().slice(0, 60) || ch.conversationKey;
@@ -898,24 +1033,34 @@ var ChannelEngine = class {
     this.egressRefs.set(egressRefKey(ref), true);
   }
   stateFor(binding) {
-    let state = this.states.get(binding.conversationKey);
-    if (!state) {
-      state = {
-        binding,
-        chatInitiated: false,
-        delivered: new TtlCache({
-          ttlMs: DELIVERED_CONTENT_TTL_MS,
-          maxEntries: DELIVERED_CONTENT_MAX_ENTRIES,
-          now: this.now
-        }),
-        replyRefs: new TtlCache({
-          ttlMs: REPLY_REF_TTL_MS,
-          maxEntries: REPLY_REF_MAX_ENTRIES,
-          now: this.now
-        })
-      };
-      this.states.set(binding.conversationKey, state);
-    }
+    const existing = this.states.get(binding.conversationKey);
+    if (existing) return existing;
+    const key = binding.conversationKey;
+    const state = {
+      binding,
+      chatInitiated: false,
+      delivered: new TtlCache({
+        ttlMs: DELIVERED_CONTENT_TTL_MS,
+        maxEntries: DELIVERED_CONTENT_MAX_ENTRIES,
+        now: this.now
+      }),
+      replyRefs: new TtlCache({
+        ttlMs: REPLY_REF_TTL_MS,
+        maxEntries: REPLY_REF_MAX_ENTRIES,
+        now: this.now
+      }),
+      context: new ContextBatcher({
+        options: this.opts.contextBatch,
+        conversationKey: key,
+        now: this.now,
+        logger: this.logger,
+        // Queued on the conversation's chain, so a timed flush never overtakes a prompt.
+        onDue: () => {
+          void this.enqueueOnKey(key, () => this.flushContext(state));
+        }
+      })
+    };
+    this.states.set(key, state);
     return state;
   }
   /** Idempotent: one OutputMirror + session subscription per bound conversation. */
@@ -943,7 +1088,9 @@ var ChannelEngine = class {
   }
   /** Engine-side filtering in front of the mirror: placeholder, loop guard, turn origin. */
   onAgentEvent(state, mirror, e) {
-    if (e.type === "text" || e.type === "finished") this.disarmPlaceholder(state);
+    if (e.type === "text" || e.type === "finished" || e.type === "error") {
+      this.disarmPlaceholder(state);
+    }
     if (e.type === "user_message" && state.delivered.has(e.content)) return;
     if (state.binding.mirrorMode === "chat-initiated" && !state.chatInitiated && (e.type === "text" || e.type === "text_retract" || e.type === "question" || e.type === "error" || e.type === "typing")) {
       return;
@@ -993,8 +1140,10 @@ var ChannelEngine = class {
       });
     }
   }
-  /** Disarm, unsubscribe, and flush/dispose the mirror of one binding. */
+  /** Flush pending context, disarm, unsubscribe, and flush/dispose the mirror of one binding. */
   async teardownState(state) {
+    await this.flushContext(state);
+    state.context.dispose();
     this.disarmPlaceholder(state);
     state.unsubscribe?.();
     state.unsubscribe = void 0;
@@ -1088,6 +1237,6 @@ function buildLookupUserTool(adapter, renderer) {
 }
 var LOOKUP_USER_PROMPT_FRAGMENT = "To @-mention a person in the chat channel, first call the lookup_user tool with their name, email, or id, then paste the returned mentionToken into your message verbatim \u2014 do not alter or re-format it. If lookup_user finds nobody, refer to the person by plain name instead.";
 
-export { ChannelEngine, LOOKUP_USER_PROMPT_FRAGMENT, OutputMirror, REJECT_NOTICE, TtlCache, TtlDedupeStore, buildLookupUserTool, consoleChannelLogger, mrkdwnFormatConverter };
+export { ChannelEngine, ContextBatcher, LOOKUP_USER_PROMPT_FRAGMENT, OutputMirror, REJECT_NOTICE, TtlCache, TtlDedupeStore, buildLookupUserTool, consoleChannelLogger, endsTurn, mrkdwnFormatConverter };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map