@standardagents/builder 0.39.0 → 0.39.1

package/dist/runtime.js

@@ -1489,6 +1489,9 @@ function normalizeToolCallMessageSequence(messages) {
   for (const message of messages) {
     const isAssistantToolCallMessage = message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
     if (!pending) {
+      if (message.role === "tool") {
+        continue;
+      }
       if (!isAssistantToolCallMessage) {
         normalized.push(message);
         continue;
@@ -7635,28 +7638,12 @@ This usually points to something I can't fix from here \u2014 for example the wo
           state.promptPath = [sideAPrompt.name];
           state.pendingImmediateAfterHandoff = true;
           if (userMessageContent || userMessageAttachments) {
-            const handoffMessageId = crypto.randomUUID();
-            const handoffTimestamp = Date.now() * 1e3;
-            const handoffMessage = {
-              id: handoffMessageId,
-              role: "user",
-              content: userMessageContent || "",
-              created_at: handoffTimestamp,
-              attachments: userMessageAttachments
-            };
-            await state.storage.sql.exec(
-              `INSERT INTO messages (id, role, content, attachments, created_at, prompt) VALUES (?, ?, ?, ?, ?, ?)`,
-              handoffMessage.id,
-              handoffMessage.role,
-              handoffMessage.content,
-              handoffMessage.attachments || null,
-              handoffMessage.created_at,
+            await this.persistHandoffUserMessage(
+              state,
+              userMessageContent || "",
+              userMessageAttachments,
               sideAPrompt.name
             );
-            state.messageHistory.push(handoffMessage);
-            if (state.emitMessage) {
-              state.emitMessage(handoffMessage);
-            }
           }
           state.pendingHandoff = void 0;
           state.emitTelemetry?.({
@@ -7671,6 +7658,37 @@ This usually points to something I can't fix from here \u2014 for example the wo
           throw error;
         }
       }
+      /**
+       * Persist the user message that rides an agent handoff, applying the
+       * create-message lifecycle hooks like every other insertion path.
+       */
+      static async persistHandoffUserMessage(state, content, attachments, promptName) {
+        let handoffMessage = {
+          id: crypto.randomUUID(),
+          role: "user",
+          content,
+          created_at: Date.now() * 1e3,
+          status: "completed",
+          attachments: attachments ?? null
+        };
+        handoffMessage = await this.runBeforeCreateMessageHook(state, handoffMessage);
+        await state.storage.sql.exec(
+          `INSERT INTO messages (id, role, content, attachments, created_at, status, silent, prompt) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+          handoffMessage.id,
+          handoffMessage.role,
+          handoffMessage.content,
+          handoffMessage.attachments || null,
+          handoffMessage.created_at,
+          handoffMessage.status ?? "completed",
+          handoffMessage.silent ? 1 : 0,
+          promptName
+        );
+        state.messageHistory.push(handoffMessage);
+        await this.runAfterCreateMessageHook(state, handoffMessage);
+        if (state.emitMessage) {
+          state.emitMessage(handoffMessage);
+        }
+      }
       static isEnabledEnvFlag(value) {
         if (value === null || value === void 0) return false;
         const normalized = value.trim().toLowerCase();
@@ -8568,7 +8586,16 @@ This usually points to something I can't fix from here \u2014 for example the wo
           role: "system",
           content: systemPromptText
         });
-        const completedMessages = state.messageHistory.filter(
+        const historySnapshot = state.messageHistory.filter(
+          (msg) => msg.status !== "pending"
+        );
+        const filteredHistory = await this.runFilterMessagesHook(
+          state.thread.instance,
+          state,
+          historySnapshot
+        );
+        const contextHistory = this.filterOrphanedToolCalls(filteredHistory);
+        const completedMessages = contextHistory.filter(
           (msg) => msg.status !== "pending"
         );
         const recentMessageThreshold = state.prompt.recentImageThreshold ?? 10;
@@ -9706,11 +9733,11 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
        * @param message - Message object to be created
        * @returns Processed message (or original if hook doesn't exist/fails)
        */
-      static async runBeforeCreateMessageHook(state, message) {
+      static async runBeforeCreateMessageHook(state, message, threadStateOverride, options) {
         const executors = await this.getHooksForType(state, "before_create_message");
         if (executors.length === 0) return message;
         let result = message;
-        const threadState = ThreadStateImpl.fromFlowState(state);
+        const threadState = threadStateOverride ?? ThreadStateImpl.fromFlowState(state);
         for (const executor of executors) {
           try {
             const hooked = await executor(threadState, _FlowEngine.rowToHookMessage(result));
@@ -9720,6 +9747,9 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
               attachments: hooked.attachments === void 0 ? result.attachments : hooked.attachments === null ? null : typeof hooked.attachments === "string" ? hooked.attachments : JSON.stringify(hooked.attachments)
             };
           } catch (error) {
+            if (options?.propagateHookErrors) {
+              throw error;
+            }
             console.error("[Hooks] \u2717 Error running before_create_message hook:", error);
           }
         }
@@ -9732,10 +9762,10 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
        * @param state - Flow state with execution context
        * @param message - The created message object
        */
-      static async runAfterCreateMessageHook(state, message) {
+      static async runAfterCreateMessageHook(state, message, threadStateOverride) {
         const executors = await this.getHooksForType(state, "after_create_message");
         if (executors.length === 0) return;
-        const threadState = ThreadStateImpl.fromFlowState(state);
+        const threadState = threadStateOverride ?? ThreadStateImpl.fromFlowState(state);
         for (const executor of executors) {
           try {
             await executor(threadState, _FlowEngine.rowToHookMessage(message));
@@ -10236,7 +10266,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
           }
           existingPathMessages.add(content);
           const attachmentsJson = JSON.stringify([ref]);
-          const silentMessage = {
+          let silentMessage = {
             id: crypto.randomUUID(),
             role: sourceMessage.role,
             content,
@@ -10247,6 +10277,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             parent_id: parentId,
             depth
           };
+          silentMessage = await this.runBeforeCreateMessageHook(state, silentMessage);
           await state.storage.sql.exec(
             `
         INSERT INTO messages (
@@ -10257,15 +10288,16 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             silentMessage.id,
             silentMessage.role,
             silentMessage.content,
-            attachmentsJson,
-            1,
+            silentMessage.attachments ?? null,
+            silentMessage.silent ? 1 : 0,
             silentMessage.created_at,
-            silentMessage.status,
+            silentMessage.status ?? "completed",
             silentMessage.parent_id,
             silentMessage.depth,
             currentPrompt
           );
           state.messageHistory.push(silentMessage);
+          await this.runAfterCreateMessageHook(state, silentMessage);
           if (state.emitMessage) {
             state.emitMessage(silentMessage);
           }
@@ -10804,7 +10836,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
        */
       static async loadMessageHistory(state) {
         const storage = state.storage;
-        const thread = state.thread;
+        state.thread;
         const includeParentHistory = state.prompt.include_chat ?? true;
         const includeToolCalls = state.prompt.include_past_tools ?? true;
         try {
@@ -10840,8 +10872,11 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             rows = cursor.toArray();
           }
           if (state.extraMessages && state.extraMessages.length > 0) {
-            rows.push(...state.extraMessages);
-            rows.sort((a, b) => a.created_at - b.created_at || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+            const persistedIds = new Set(rows.map((row) => row.id));
+            rows.push(
+              ...state.extraMessages.filter((entry) => !persistedIds.has(entry.id))
+            );
+            rows.sort((a, b) => a.created_at - b.created_at);
           }
           const messages = rows.map((row) => ({
             id: row.id,
@@ -10864,24 +10899,15 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             reasoning_content: row.reasoning_content,
             reasoning_details: row.reasoning_details
           }));
-          return this.runFilterMessagesHook(
-            thread.instance,
-            state,
-            this.filterOrphanedToolCalls(messages)
-          );
+          return messages;
         } catch (error) {
           console.error("Error loading message history:", error);
           return [];
         }
       }
       /**
-       * Run the filter_messages hook if it exists
-       * This hook allows developers to modify SQL row data before transformation
-       *
-       * @param thread - Thread instance with hooks registry
-       * @param state - Flow state for hook context
-       * @param rows - SQL rows from messages table
-       * @returns Processed rows (or original if hook doesn't exist/fails)
+       * Build request-context rows from persisted history.
+       * Mutations and synthetic messages stay in the request context.
        */
       static async runFilterMessagesHook(thread, state, messages) {
         const executors = await this.getHooksForType(state, "filter_messages");
@@ -10894,13 +10920,56 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             for (const row of result) if (row.id) byId.set(row.id, row);
             const hookView = result.map((row) => _FlowEngine.rowToHookMessage(row));
             const kept = await executor(threadState, hookView);
-            result = kept.map((m) => m.id && byId.get(m.id) || null).filter((row) => row !== null);
+            result = kept.map((hookedMessage) => {
+              const original = hookedMessage.id ? byId.get(hookedMessage.id) : void 0;
+              if (original) {
+                return _FlowEngine.applyHookMessageToRow(original, hookedMessage);
+              }
+              return _FlowEngine.hookMessageToContextRow(hookedMessage);
+            });
           } catch (error) {
             console.error("[Hooks] \u2717 Error running filter_messages hook:", error);
           }
         }
         return result;
       }
+      /**
+       * Copy a persisted row and apply hook edits. The original live-history
+       * object is left unchanged.
+       */
+      static applyHookMessageToRow(original, hooked) {
+        const attachments = hooked.attachments === void 0 ? original.attachments : hooked.attachments === null ? null : typeof hooked.attachments === "string" ? hooked.attachments : JSON.stringify(hooked.attachments);
+        return {
+          ...original,
+          role: hooked.role ?? original.role,
+          content: hooked.content !== void 0 ? hooked.content : original.content,
+          name: hooked.name !== void 0 ? hooked.name : original.name,
+          tool_calls: hooked.tool_calls !== void 0 ? hooked.tool_calls : original.tool_calls,
+          tool_call_id: hooked.tool_call_id !== void 0 ? hooked.tool_call_id : original.tool_call_id,
+          silent: hooked.silent !== void 0 ? hooked.silent : original.silent,
+          attachments
+        };
+      }
+      /**
+       * Convert a synthetic hook message into a request-context-only builder row.
+       */
+      static hookMessageToContextRow(hooked) {
+        const attachments = hooked.attachments === void 0 || hooked.attachments === null ? hooked.attachments ?? null : typeof hooked.attachments === "string" ? hooked.attachments : JSON.stringify(hooked.attachments);
+        return {
+          id: hooked.id || crypto.randomUUID(),
+          role: hooked.role,
+          content: hooked.content ?? null,
+          name: hooked.name ?? null,
+          tool_calls: typeof hooked.tool_calls === "string" ? hooked.tool_calls : null,
+          tool_call_id: hooked.tool_call_id ?? null,
+          created_at: hooked.created_at ?? Date.now() * TIMESTAMP_MULTIPLIER,
+          parent_id: hooked.parent_id ?? null,
+          depth: hooked.depth ?? 0,
+          silent: hooked.silent ?? false,
+          status: "completed",
+          attachments
+        };
+      }
       /**
        * Log an error to the logs table (best-effort)
        * Creates a log entry with error details but no associated message_id
@@ -11044,6 +11113,35 @@ ${errorStack}` : ""}`;
 });
 
 // src/agents/utilities.ts
+var utilities_exports = {};
+__export(utilities_exports, {
+  cat: () => cat,
+  emitThreadEvent: () => emitThreadEvent,
+  exists: () => exists,
+  find: () => find,
+  forceTurn: () => forceTurn,
+  getFileStats: () => getFileStats,
+  getMessages: () => getMessages,
+  getThumbnail: () => getThumbnail,
+  grep: () => grep,
+  head: () => head,
+  injectMessage: () => injectMessage,
+  linkFile: () => linkFile,
+  mkdir: () => mkdir,
+  move: () => move,
+  queueTool: () => queueTool,
+  readFile: () => readFile,
+  readdir: () => readdir,
+  reloadHistory: () => reloadHistory,
+  rename: () => rename,
+  rmdir: () => rmdir,
+  stat: () => stat,
+  tail: () => tail,
+  unlink: () => unlink,
+  updateThread: () => updateThread,
+  writeFile: () => writeFile,
+  writeImage: () => writeImage
+});
 function queueTool(flow, toolName, args = {}) {
   if (flow.currentToolUses !== void 0) {
     if (!flow.currentToolUses.includes(toolName)) {
@@ -11071,7 +11169,7 @@ async function injectMessage(flow, options) {
   const timestamp = Date.now() * TIMESTAMP_MULTIPLIER;
   const silent = options.silent ?? false;
   const forceTopLevel = options.forceTopLevel ?? false;
-  const message = {
+  let message = {
     id: messageId,
     role: options.role,
     content: options.content,
@@ -11085,41 +11183,52 @@ async function injectMessage(flow, options) {
     metadata: options.metadata
   };
   if (options.beforeMessageId) {
-    const cursor = await flow.storage.sql.exec(
-      `SELECT created_at FROM messages WHERE id = ?`,
-      options.beforeMessageId
+    const liveTarget = flow.messageHistory.find(
+      (entry) => entry.id === options.beforeMessageId
     );
-    const rows = cursor.toArray();
-    const targetMessage = rows[0];
-    if (!targetMessage) {
-      throw new Error(
-        `Message with id ${options.beforeMessageId} not found`
+    let targetCreatedAt = liveTarget?.created_at;
+    if (targetCreatedAt === void 0) {
+      const cursor = await flow.storage.sql.exec(
+        `SELECT created_at FROM messages WHERE id = ?`,
+        options.beforeMessageId
       );
+      const rows = cursor.toArray();
+      const targetMessage = rows[0];
+      if (!targetMessage) {
+        throw new Error(
+          `Message with id ${options.beforeMessageId} not found`
+        );
+      }
+      targetCreatedAt = targetMessage.created_at;
     }
-    message.created_at = targetMessage.created_at - 1;
+    message.created_at = targetCreatedAt - 1;
   }
   const currentPrompt = flow.promptPath.length > 0 ? flow.promptPath[flow.promptPath.length - 1] : null;
-  const metadataJson = options.metadata ? JSON.stringify(options.metadata) : null;
+  const { FlowEngine: FlowEngine2 } = await Promise.resolve().then(() => (init_FlowEngine(), FlowEngine_exports));
+  message = await FlowEngine2.runBeforeCreateMessageHook(flow, message, void 0, {
+    propagateHookErrors: true
+  });
+  const metadataJson = message.metadata === void 0 ? null : JSON.stringify(message.metadata);
   await flow.storage.sql.exec(
     `INSERT INTO messages (id, role, content, name, tool_call_id, created_at, status, silent, parent_id, depth, metadata, prompt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    messageId,
+    message.id,
     message.role,
     message.content,
     message.name,
     message.tool_call_id,
     message.created_at,
     message.status,
-    silent ? 1 : 0,
+    message.silent ? 1 : 0,
     message.parent_id,
     message.depth,
     metadataJson,
     currentPrompt
   );
-  if (!silent) {
-    flow.messageHistory.push(message);
-  } else {
-    flow.messageHistory = await reloadHistory(flow);
+  appendLiveExecutionHistory(flow, message, options.beforeMessageId);
+  if (flow.prompt.include_chat === false || message.parent_id !== null || (message.depth ?? 0) > 0) {
+    appendInjectedContextMessage(flow.extraMessages, message);
   }
+  await FlowEngine2.runAfterCreateMessageHook(flow, message);
   if (flow.emitMessage) {
     flow.emitMessage(message);
   }
@@ -11128,6 +11237,42 @@ async function injectMessage(flow, options) {
   }
   return message;
 }
+function appendLiveExecutionHistory(flow, message, beforeMessageId) {
+  const history = flow.messageHistory;
+  const existing = history.findIndex((entry) => entry.id === message.id);
+  if (existing >= 0) {
+    history.splice(existing, 1);
+  }
+  if (beforeMessageId) {
+    const targetIndex = history.findIndex((entry) => entry.id === beforeMessageId);
+    if (targetIndex >= 0) {
+      history.splice(targetIndex, 0, message);
+      return;
+    }
+  }
+  const insertAt = history.findIndex(
+    (entry) => entry.created_at > message.created_at
+  );
+  if (insertAt === -1) {
+    history.push(message);
+    return;
+  }
+  history.splice(insertAt, 0, message);
+}
+function appendInjectedContextMessage(extraMessages, message) {
+  const existing = extraMessages.findIndex((entry) => entry.id === message.id);
+  if (existing >= 0) {
+    extraMessages.splice(existing, 1);
+  }
+  const insertAt = extraMessages.findIndex(
+    (entry) => entry.created_at > message.created_at
+  );
+  if (insertAt === -1) {
+    extraMessages.push(message);
+    return;
+  }
+  extraMessages.splice(insertAt, 0, message);
+}
 async function getMessages(flow, limit = 100, offset = 0, order = "asc") {
   const orderClause = order === "desc" ? "DESC" : "ASC";
   const cursor = await flow.storage.sql.exec(
@@ -21555,6 +21700,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
 // src/durable-objects/DurableThread.ts
 init_StreamManager();
 init_LLMRequest();
+init_ThreadStateImpl();
 
 // src/durable-objects/logDetailStream.ts
 var LOG_DETAIL_HEAVY_FIELDS = [
@@ -22257,7 +22403,8 @@ var DurableThread = class _DurableThread extends DurableObject {
       side_b_session_fail_attachments_property: sideBSession.fail.attachmentsProperty,
       side_b_session_status_tool: sideBSession.status.toolName,
       side_b_session_status_message_property: sideBSession.status.messageProperty,
-      side_b_session_status_attachments_property: sideBSession.status.attachmentsProperty
+      side_b_session_status_attachments_property: sideBSession.status.attachmentsProperty,
+      hooks: Array.isArray(agentDef.hooks) ? agentDef.hooks : void 0
     };
   }
   /**
@@ -22927,6 +23074,29 @@ var DurableThread = class _DurableThread extends DurableObject {
     }
     return projections;
   }
+  /**
+   * Build hook resolution context and a genuine at-rest ThreadState.
+   * Resolution failures abort insertion so lifecycle hooks cannot be bypassed.
+   */
+  async buildAtRestHookState(threadId) {
+    try {
+      const metadata = await this.getThreadMetadata(threadId);
+      const agentConfig = await this.loadAgentConfig(metadata.agent_id);
+      const threadInstance = this;
+      return {
+        hookState: {
+          agentConfig,
+          thread: { instance: threadInstance, metadata }
+        },
+        threadState: ThreadStateImpl.fromThreadInstance(threadInstance, metadata)
+      };
+    } catch (error) {
+      throw new Error(
+        `Unable to resolve create-message hooks for ${threadId}`,
+        { cause: error }
+      );
+    }
+  }
   /**
    * Inject a top-level message without starting a new execution.
    *
@@ -22939,22 +23109,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     const id = crypto.randomUUID();
     const createdAt = Date.now() * TIMESTAMP_MULTIPLIER;
     const silent = message.silent === true;
-    const metadataJson = message.metadata ? JSON.stringify(message.metadata) : null;
-    await this.ctx.storage.sql.exec(
-      `INSERT INTO messages (id, role, content, created_at, status, silent, parent_id, depth, metadata, prompt)
-       VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)`,
-      id,
-      message.role,
-      message.content,
-      createdAt,
-      "completed",
-      silent ? 1 : 0,
-      null,
-      0,
-      metadataJson,
-      null
-    );
-    const inserted = {
+    let inserted = {
       id,
       role: message.role,
       content: message.content,
@@ -22965,9 +23120,37 @@ var DurableThread = class _DurableThread extends DurableObject {
       depth: 0,
       metadata: message.metadata
     };
+    const { hookState, threadState } = await this.buildAtRestHookState(threadId);
+    const { FlowEngine: FlowEngine2 } = await Promise.resolve().then(() => (init_FlowEngine(), FlowEngine_exports));
+    inserted = await FlowEngine2.runBeforeCreateMessageHook(
+      hookState,
+      inserted,
+      threadState,
+      { propagateHookErrors: true }
+    );
+    const metadataJson = inserted.metadata ? JSON.stringify(inserted.metadata) : null;
+    await this.ctx.storage.sql.exec(
+      `INSERT INTO messages (id, role, content, created_at, status, silent, parent_id, depth, metadata, prompt)
+       VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)`,
+      inserted.id,
+      inserted.role,
+      inserted.content,
+      inserted.created_at,
+      inserted.status ?? "completed",
+      inserted.silent ? 1 : 0,
+      inserted.parent_id ?? null,
+      inserted.depth ?? 0,
+      metadataJson,
+      null
+    );
+    await FlowEngine2.runAfterCreateMessageHook(
+      hookState,
+      inserted,
+      threadState
+    );
     this.broadcastMessage(inserted);
     const record = inserted;
-    const visibleUserInjection = message.role === "user" && !silent && typeof message.content === "string" && message.content.trim().length > 0 && !isRuntimeSubagentEnvelope(message.content);
+    const visibleUserInjection = inserted.role === "user" && !inserted.silent && typeof inserted.content === "string" && inserted.content.trim().length > 0 && !isRuntimeSubagentEnvelope(inserted.content);
     if (visibleUserInjection || isVisibleTerminalAssistantMessage(record)) {
       const stamp = this.recordRegistryActivity(
         threadId,
@@ -29462,8 +29645,7 @@ var DurableUserHub = class extends DurableObject {
 init_utilities();
 
 // src/agents/FlowStateSdk.ts
-init_types();
-var FlowStateSdk = class _FlowStateSdk {
+var FlowStateSdk = class {
   /**
    * Queue a new tool call to be executed in the current flow
    *
@@ -29530,63 +29712,8 @@ var FlowStateSdk = class _FlowStateSdk {
    * ```
    */
   static async injectMessage(flow, options) {
-    const messageId = options.id ?? crypto.randomUUID();
-    const timestamp = Date.now() * TIMESTAMP_MULTIPLIER;
-    const silent = options.silent ?? false;
-    const forceTopLevel = options.forceTopLevel ?? false;
-    const message = {
-      id: messageId,
-      role: options.role,
-      content: options.content,
-      name: options.name ?? null,
-      tool_call_id: options.toolCallId ?? null,
-      created_at: timestamp,
-      status: "completed",
-      silent,
-      parent_id: forceTopLevel ? null : flow.parentMessageId ?? null,
-      depth: forceTopLevel ? 0 : flow.depth
-    };
-    if (options.beforeMessageId) {
-      const cursor = await flow.storage.sql.exec(
-        `SELECT created_at FROM messages WHERE id = ?`,
-        options.beforeMessageId
-      );
-      const rows = cursor.toArray();
-      const targetMessage = rows[0];
-      if (!targetMessage) {
-        throw new Error(
-          `Message with id ${options.beforeMessageId} not found`
-        );
-      }
-      message.created_at = targetMessage.created_at - 1;
-    }
-    const currentPrompt = flow.promptPath.length > 0 ? flow.promptPath[flow.promptPath.length - 1] : null;
-    await flow.storage.sql.exec(
-      `INSERT INTO messages (id, role, content, name, tool_call_id, created_at, status, silent, parent_id, depth, prompt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      messageId,
-      message.role,
-      message.content,
-      message.name,
-      message.tool_call_id,
-      message.created_at,
-      message.status,
-      silent ? 1 : 0,
-      message.parent_id,
-      message.depth,
-      currentPrompt
-    );
-    if (!silent) {
-      flow.messageHistory.push(message);
-    } else {
-      flow.messageHistory = await _FlowStateSdk.reloadHistory(flow);
-    }
-    if (flow.emitMessage) {
-      flow.emitMessage(message);
-    }
-    if (options.forceTurn) {
-      _FlowStateSdk.forceTurn(flow, options.forceTurn);
-    }
-    return message;
+    const { injectMessage: injectMessage2 } = await Promise.resolve().then(() => (init_utilities(), utilities_exports));
+    return injectMessage2(flow, options);
   }
   /**
    * Get messages from the thread history
@@ -29675,9 +29802,9 @@ var FlowStateSdk = class _FlowStateSdk {
   /**
    * Reload message history from storage
    *
-   * Re-loads the complete message history from the thread's SQLite storage,
-   * applying any filter_messages hooks. This is useful when you need to refresh
-   * the message history after making changes (e.g., injecting silent messages).
+   * Re-loads the complete message history from the thread's SQLite storage.
+   * This is useful when you need to refresh the message history after making
+   * changes (e.g., injecting messages).
    *
    * @param flow - The current FlowState
    * @returns Array of messages (reloaded from storage)