@zhivex-ai/core 1.16.1 → 1.18.0

package/dist/agent.js

@@ -1,3 +1,4 @@
+import { refreshAgentTaskOutcome } from "./agent-reconciliation.js";
 import { createHash } from "node:crypto";
 import { createAgentApprovalMessage, getAgentApprovalRequests } from "./agent-approval.js";
 import { createAgentHandoffMessage } from "./agent-handoff-contracts.js";
@@ -113,6 +114,7 @@ const cloneMetadata = (...values) => {
 };
 const toOutput = (state) => ({
     status: state.status,
+    taskOutcome: state.taskOutcome,
     outputText: state.outputText,
     finalOutput: state.status === "completed" && state.finalOutput !== undefined
         ? state.finalOutput
@@ -637,19 +639,19 @@ export const createSubAgentTool = (options) => {
         }
     };
 };
-const saveStateWithRevision = async (store, state) => {
+const saveStateWithRevision = async (store, state, serializedNextState) => {
     const expectedRevision = state.revision ?? 0;
     const nextRevision = expectedRevision + 1;
     const nextState = { ...state, revision: nextRevision };
-    await store.save(cloneState(nextState), { expectedRevision });
+    await store.save(serializedNextState === undefined ? cloneState(nextState) : JSON.parse(serializedNextState), { expectedRevision });
     state.revision = nextRevision;
 };
 const claimAgentExecution = async (agent, state) => {
     state.status = "running";
     state.updatedAt = Date.now();
-    assertStateSize(agent, state);
+    const serialized = assertStateSize(agent, agent.store ? normalizeAgentRunState({ ...state, revision: (state.revision ?? 0) + 1 }) : state);
     if (agent.store) {
-        await saveStateWithRevision(agent.store, state);
+        await saveStateWithRevision(agent.store, state, serialized);
     }
 };
 const assertStateSize = (agent, state, policy) => {
@@ -657,16 +659,19 @@ const assertStateSize = (agent, state, policy) => {
     if (!Number.isSafeInteger(limit) || limit < 1) {
         throw new ValidationError('Agent policy "maxStateBytes" must be a positive integer.');
     }
-    const bytes = new TextEncoder().encode(JSON.stringify(state)).byteLength;
+    const serialized = JSON.stringify(state);
+    const bytes = new TextEncoder().encode(serialized).byteLength;
     if (bytes > limit) {
         throw new ValidationError(`Agent run state is ${bytes} bytes and exceeds maxStateBytes=${limit}. Offload large tool outputs to artifacts or raise the explicit limit.`);
     }
+    return serialized;
 };
 const persistState = async (agent, state, policy) => {
     state.updatedAt = Date.now();
-    assertStateSize(agent, state, policy);
+    await refreshAgentTaskOutcome(state, agent.store);
+    const serialized = assertStateSize(agent, agent.store ? normalizeAgentRunState({ ...state, revision: (state.revision ?? 0) + 1 }) : state, policy);
     if (agent.store) {
-        await saveStateWithRevision(agent.store, state);
+        await saveStateWithRevision(agent.store, state, serialized);
     }
     await emitTelemetryEvent(agent, {
         type: "state-saved",
@@ -848,6 +853,11 @@ const resolveContext = async (agent, input) => {
     ensureValidStateInput(normalizedInput);
     const metadata = cloneMetadata(agent.metadata, loadedState?.metadata, input.metadata, input.handoff?.metadata);
     if (loadedState) {
+        const groupIdentity = input.metadata?.agentGroupIdentity;
+        if (groupIdentity !== undefined && (loadedState.metadata?.agentGroupIdentity !== groupIdentity ||
+            loadedState.agentId !== agent.id)) {
+            throw new ConflictError("Agent group idempotency key belongs to a different member or agent.");
+        }
         bindDurableRuntime(agent, input, loadedState, executionEnvironmentBinding);
         const maxSteps = input.maxSteps ?? loadedState.maxSteps;
         const resumed = await applyApprovalResponses(loadedState.messages, input.approvals, loadedState.pendingApprovals, loadedState.approvalHistory, agent.toolApprovalSigner);
@@ -967,6 +977,9 @@ const wrapToolWithJournal = (agent, state, tool) => {
                 throw new ValidationError(`Durable tool "${tool.name}" requires an execution context.`);
             }
             const serializedInput = serializeJsonValue(input);
+            const confirmed = state.reconciliations?.find(record => record.evidence.toolName === tool.name && canonicalJson(record.evidence.input) === canonicalJson(serializedInput));
+            if (confirmed)
+                return confirmed.evidence.output;
             const step = context.step;
             const toolCallId = durableToolCallId(state.runId, step, context.toolCall.id, tool.name, serializedInput);
             const idempotencyKey = `${state.runId}:${toolCallId}`;
@@ -975,6 +988,7 @@ const wrapToolWithJournal = (agent, state, tool) => {
                 runId: state.runId,
                 scope: state.scope,
                 toolCallId,
+                providerToolCallId: context.toolCall.id,
                 toolName: tool.name,
                 status: "pending",
                 idempotencyKey,
@@ -1255,7 +1269,7 @@ const createGenerateOptions = (agent, state, input, messages, maxSteps, context,
     ].filter((value) => value !== undefined);
     const maxTokens = tokenCeilings.length ? Math.min(...tokenCeilings) : undefined;
     const requestedToolExecution = input.toolExecution ?? agent.toolExecution;
-    const toolExecution = agent.subagents?.length
+    const toolExecution = agent.subagents?.length && !(requestedToolExecution?.parallel && requestedToolExecution.independentOnly)
         ? {
             ...requestedToolExecution,
             parallel: false,
@@ -1850,7 +1864,39 @@ export const prepareSubagentsForAgent = (agent, options = {}) => {
     };
 };
 export const runAgentGroup = async (agents, input = {}) => {
-    const { stopOnError, runId: _runId, state: _state, approvals: _approvals, handoff: _handoff, ...sharedInput } = input;
+    const { stopOnError, maxConcurrency, runId: _runId, state: _state, approvals: _approvals, handoff: _handoff, ...sharedInput } = input;
+    if (maxConcurrency !== undefined && (!Number.isSafeInteger(maxConcurrency) || maxConcurrency < 1)) {
+        throw new ValidationError('Agent group "maxConcurrency" must be a positive safe integer.');
+    }
+    // Validate the complete group before any member can claim a key or invoke a model.
+    const identities = new Set();
+    const claims = [];
+    const memberInputs = agents.map((member) => {
+        const merged = { ...sharedInput, ...member.input };
+        ensureValidScope(merged.scope);
+        ensureValidIdempotencyInput(merged, member.agent.store);
+        if (!merged.idempotencyKey)
+            return merged;
+        const identity = member.name ?? member.agent.id;
+        if (!identity || identities.has(identity)) {
+            throw new ValidationError("Idempotent agent group members require unique names or agent IDs.");
+        }
+        identities.add(identity);
+        const key = member.input?.idempotencyKey ?? `agent-group:${JSON.stringify([input.idempotencyKey, identity])}`;
+        const scope = merged.scope;
+        const scopedKey = JSON.stringify([scope?.namespace ?? "default", scope?.tenantId, scope?.userId, key]);
+        if (claims.some((claim) => claim.store === member.agent.store && claim.key === scopedKey)) {
+            throw new ConflictError("Agent group members cannot share an explicit idempotency key in the same store and scope.");
+        }
+        claims.push({ store: member.agent.store, key: scopedKey });
+        return {
+            ...merged,
+            idempotencyKey: key,
+            metadata: cloneMetadata(input.metadata, member.input?.metadata, {
+                agentGroupIdentity: JSON.stringify([input.idempotencyKey ?? null, identity])
+            })
+        };
+    });
     const parentRunId = input.parentRunId;
     const controllers = agents.map(() => new AbortController());
     let failFastTriggered = false;
@@ -1866,15 +1912,17 @@ export const runAgentGroup = async (agents, input = {}) => {
             }
         });
     };
-    const runs = agents.map(async (member, index) => {
+    const runMember = async (member, index) => {
         const merged = createMergedAbortSignal(input.abortSignal, member.input?.abortSignal, controllers[index].signal);
         try {
+            if (merged.signal?.aborted) {
+                throw new DOMException("Agent group member aborted before execution.", "AbortError");
+            }
             const runInput = {
-                ...sharedInput,
-                ...(member.input ?? {}),
+                ...memberInputs[index],
                 parentRunId: member.input?.parentRunId ?? parentRunId,
                 abortSignal: merged.signal,
-                metadata: cloneMetadata(input.metadata, member.input?.metadata, {
+                metadata: cloneMetadata(input.metadata, memberInputs[index]?.metadata, {
                     ...(member.name ? { agentGroupMember: member.name } : {})
                 })
             };
@@ -1891,8 +1939,20 @@ export const runAgentGroup = async (agents, input = {}) => {
         finally {
             merged.cleanup();
         }
-    });
-    const settled = await Promise.allSettled(runs);
+    };
+    const settled = new Array(agents.length);
+    let nextIndex = 0;
+    await Promise.all(Array.from({ length: Math.min(maxConcurrency ?? agents.length, agents.length) }, async () => {
+        while (nextIndex < agents.length) {
+            const index = nextIndex++;
+            try {
+                settled[index] = { status: "fulfilled", value: await runMember(agents[index], index) };
+            }
+            catch (reason) {
+                settled[index] = { status: "rejected", reason };
+            }
+        }
+    }));
     const outputs = settled.map((result, index) => {
         const member = agents[index];
         if (result.status === "fulfilled") {
@@ -1916,9 +1976,12 @@ export const runAgentGroup = async (agents, input = {}) => {
             }
         };
     });
-    const failed = outputs.some((output) => output.status === "rejected" || output.output?.status === "failed" || output.output?.status === "timed_out");
+    const precedence = [
+        "failed", "timed_out", "cancel_requested", "running", "queued", "waiting_approval", "suspended", "cancelled", "completed"
+    ];
+    const status = precedence.find((status) => outputs.some((output) => output.status === "rejected" ? status === "failed" : output.output?.status === status)) ?? "completed";
     return {
-        status: stopOnError && failed ? "failed" : failed ? "failed" : "completed",
+        status,
         parentRunId,
         outputs
     };
@@ -2125,6 +2188,7 @@ export const runAgent = async (agent, input = {}) => {
                 ...approvalsFromEvents(newSteps.flatMap((step) => step.response?.messages ?? []))
             ]);
             await persistState(agent, output.state, policy);
+            output.taskOutcome = output.state.taskOutcome;
             await emitRunFinishTelemetry(agent, output.state);
             executionEnvironmentStatus = output.status;
             return returnInvocationOutput(output);
@@ -2456,6 +2520,7 @@ export const streamAgent = (agent, input = {}) => {
                     await emitApprovalTelemetry(agent, result.state, approvalsFromEvents(newSteps.flatMap((step) => step.response?.messages ?? [])));
                 }
                 await persistState(agent, result.state, policy);
+                result.taskOutcome = result.state.taskOutcome;
                 await emitRunFinishTelemetry(agent, result.state);
                 await publish({
                     type: "agent-run-finish",