@axiom-lattice/core 10.0.3 → 10.0.4

package/dist/index.mjs

@@ -39,6 +39,7 @@ import {
 import {
   BaseLanguageModel
 } from "@langchain/core/language_models/base";
+import { ChatGenerationChunk } from "@langchain/core/outputs";
 var ModelLattice = class extends BaseChatModel {
   /**
    * 构造函数
@@ -93,11 +94,33 @@ var ModelLattice = class extends BaseChatModel {
    * @remarks BaseChatModel's streaming hook is `_streamResponseChunks`. Without
    * this override the wrapper falls back to `_generate`, losing streaming and
    * provider-level cancellation.
+   *
+   * The yielded value MUST be a `ChatGenerationChunk`. Calling
+   * `this.llm.stream()` yields bare messages, and LangChain reads
+   * `chunk.message.id` from whatever this hook yields — so returning messages
+   * throws `Cannot read properties of undefined (reading 'id')` whenever a
+   * streaming-preferring callback (for example LangGraph's message stream or
+   * the summarization middleware's inherited callbacks) routes `invoke`
+   * through this hook.
    */
   async *_streamResponseChunks(messages, options, runManager) {
-    void runManager;
-    const stream = await this.llm.stream(messages, options);
-    for await (const chunk of stream) yield chunk;
+    const underlying = this.llm;
+    const streamResponseChunks = underlying._streamResponseChunks;
+    if (typeof streamResponseChunks === "function" && streamResponseChunks !== BaseChatModel.prototype._streamResponseChunks) {
+      yield* streamResponseChunks.call(underlying, messages, options, runManager);
+      return;
+    }
+    const stream = await underlying.stream(messages, options);
+    for await (const chunk of stream) {
+      if (chunk instanceof ChatGenerationChunk) {
+        yield chunk;
+        continue;
+      }
+      yield new ChatGenerationChunk({
+        message: chunk,
+        text: typeof chunk.content === "string" ? chunk.content : ""
+      });
+    }
   }
   /**
    * Whether the configured model supports vision/image inputs.
@@ -23166,6 +23189,7 @@ import {
 } from "@langchain/langgraph";
 
 // src/agent_worker/delegation_service.ts
+import { randomUUID as randomUUID10 } from "crypto";
 import { resolveRunScope } from "@axiom-lattice/protocols";
 
 // src/services/Agent.ts
@@ -29571,6 +29595,11 @@ var DELEGATION_LEASE_TTL_MS = (() => {
   const configured2 = Number(process.env.DELEGATION_LEASE_TTL_MS);
   return Number.isFinite(configured2) && configured2 > 0 ? configured2 : 6e4;
 })();
+function isOfficialResumeMap(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((key5) => isOfficialInterruptId(key5));
+}
 var DelegatedThreadBusyError = class extends Error {
   constructor(threadId) {
     super(`Delegated thread ${threadId} is already running`);
@@ -29651,12 +29680,27 @@ var DelegationService = class {
         if (cancellation.signal.aborted) onCancel();
         else cancellation.signal.addEventListener("abort", onCancel, { once: true });
       }
+      let command = request.command;
+      if (command) {
+        let state;
+        try {
+          state = await agent.getCurrentState();
+        } catch {
+          state = void 0;
+        }
+        const interrupts = state === void 0 ? [] : normalizeAgentInterrupts(state, request.thread_id);
+        const sole = interrupts.length === 1 ? interrupts[0] : void 0;
+        if (sole !== void 0 && isOfficialInterruptId(sole.interruptId) && !isOfficialResumeMap(command.resume)) {
+          command = { ...command, resume: { [sole.interruptId]: command.resume } };
+        }
+      }
       try {
-        const invocation = agent.invokeWithState({
-          input: request.input,
-          command: request.command,
-          custom_run_config: request.runConfig
-        }, signal, { allowUnmanagedCommand: true });
+        const invocation = agent.executeRun({
+          runId: randomUUID10(),
+          ...command ? { command } : { input: request.input },
+          config: request.runConfig,
+          signal
+        });
         let rejectAborted;
         const onAbort = () => rejectAborted?.(new Error("Delegated child aborted"));
         const aborted = new Promise((_resolve, reject) => {
@@ -38663,7 +38707,7 @@ async function disconnectAllChannels(getAdapter) {
 }
 
 // src/channel/ChannelConnectionLeader.ts
-import { createHash as createHash5, randomUUID as randomUUID10 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID11 } from "crypto";
 var LEASE_KEY = "leader:channel-connections";
 function channelShardForInstallation(installationId, shardCount) {
   if (!Number.isSafeInteger(shardCount) || shardCount < 1) {
@@ -38811,7 +38855,7 @@ var ChannelConnectionLeader = class {
     await this.tryAcquire();
   }
   async tryAcquire() {
-    const holder = `${this.deps.owner}#${randomUUID10()}`;
+    const holder = `${this.deps.owner}#${randomUUID11()}`;
     const acquired = await this.deps.leaseStore.tryAcquire(this.leaseKey, holder, this.ttlMs).catch((error) => {
       this.deps.log?.warn("Channel leader lease acquire failed", {
         error: error instanceof Error ? error.message : String(error)
@@ -40392,7 +40436,7 @@ function getCoordinationLeaseStore() {
 }
 
 // src/services/withLease.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 var LeaseAcquisitionTimeoutError = class extends Error {
   /**
    * @param key Lease key that could not be acquired.
@@ -40417,7 +40461,7 @@ async function withLease(store2, key5, ownerLabel, fn, options = {}) {
   const acquireTimeoutMs = options.acquireTimeoutMs ?? 1e4;
   const retryDelayMs = options.retryDelayMs ?? 50;
   const heartbeatMs = options.heartbeatMs ?? Math.max(1e3, Math.floor(ttlMs / 3));
-  const holder = `${ownerLabel}#${randomUUID11()}`;
+  const holder = `${ownerLabel}#${randomUUID12()}`;
   const deadline = Date.now() + acquireTimeoutMs;
   for (; ; ) {
     if (await store2.tryAcquire(key5, holder, ttlMs)) break;
@@ -40524,7 +40568,7 @@ function createTrustedAgentMessageDispatcher(resolve4) {
 }
 
 // src/services/RoomAgentMessageService.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 import { snapshotExactArray, snapshotExactRecord as snapshotExactRecord5 } from "@axiom-lattice/protocols";
 var INPUT_KEYS = [
   "tenantId",
@@ -40614,7 +40658,7 @@ var RoomAgentMessageService = class {
       throw new Error("Invalid project room membership");
     }
     const candidate = {
-      id: (this.deps.idFactory ?? randomUUID12)(),
+      id: (this.deps.idFactory ?? randomUUID13)(),
       tenantId: member.tenantId,
       workspaceId: member.workspaceId,
       projectId: member.projectId,
@@ -40657,7 +40701,7 @@ var RoomAgentMessageService = class {
       throw new Error("Invalid project room membership");
     }
     const candidate = {
-      id: (this.deps.idFactory ?? randomUUID12)(),
+      id: (this.deps.idFactory ?? randomUUID13)(),
       tenantId: input.tenantId,
       workspaceId: input.workspaceId,
       projectId: input.projectId,
@@ -43549,7 +43593,7 @@ function createTaskLifecycleService(deps) {
 }
 
 // src/services/TaskExecutionService.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 import { isExecutionResultEventKey as isExecutionResultEventKey2 } from "@axiom-lattice/protocols";
 
@@ -43905,13 +43949,13 @@ async function reconcileAllTenantTaskRuns(input) {
 }
 
 // src/services/taskRunLease.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 function taskRunLeaseKey(taskId) {
   return `task-run:${taskId}`;
 }
 async function tryAcquireTaskRun(input) {
   const key5 = taskRunLeaseKey(input.taskId);
-  const holder = `${input.owner}#${randomUUID13()}`;
+  const holder = `${input.owner}#${randomUUID14()}`;
   if (!await input.store.tryAcquire(key5, holder, input.ttlMs)) return null;
   const heartbeatMs = input.heartbeatMs ?? Math.max(1e3, Math.floor(input.ttlMs / 3));
   let released = false;
@@ -44331,11 +44375,11 @@ function createTaskExecutionService(deps) {
     let threadId;
     let runId;
     try {
-      threadId = storedThreadId ?? (deps.createThreadId ?? randomUUID14)();
+      threadId = storedThreadId ?? (deps.createThreadId ?? randomUUID15)();
       if (task.status === "interrupted" && reuseCurrentRun) {
         runId = storedRunId;
       } else if (task.status === "interrupted" || task.status === "failed") {
-        runId = (deps.createRunId ?? randomUUID14)();
+        runId = (deps.createRunId ?? randomUUID15)();
       }
     } catch (error) {
       return {
@@ -44615,11 +44659,11 @@ function createTaskExecutionService(deps) {
 }
 
 // src/services/leadership.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 async function runAsLeader(store2, name, fn, options = {}) {
   const key5 = `leader:${name}`;
   const owner3 = options.owner ?? getReplicaId();
-  const holder = `${owner3}#${randomUUID15()}`;
+  const holder = `${owner3}#${randomUUID16()}`;
   const ttlMs = options.ttlMs ?? 6e4;
   if (!await store2.tryAcquire(key5, holder, ttlMs)) return { ran: false };
   const heartbeat = setInterval(() => {