@cuylabs/agent-core 4.8.1 → 4.10.0

package/dist/chunk-MJRZ2ZRI.js

@@ -0,0 +1,498 @@
+import {
+  accumulateUsage,
+  cloneUsage,
+  mergeAgentTurnStateProgress
+} from "./chunk-E66PKKDL.js";
+
+// src/execution/workflow/state.ts
+function cloneMessageSnapshot(message) {
+  return {
+    ...message,
+    ...message.role === "assistant" && message.toolCalls ? {
+      toolCalls: message.toolCalls.map((toolCall) => ({ ...toolCall }))
+    } : {},
+    ...message.role === "assistant" && message.tokens ? {
+      tokens: { ...message.tokens }
+    } : {},
+    ...message.role === "assistant" && message.error ? {
+      error: { ...message.error }
+    } : {},
+    ...message.role === "tool" && message.metadata ? {
+      metadata: structuredClone(message.metadata)
+    } : {},
+    ..."contextFragment" in message && message.contextFragment ? {
+      contextFragment: structuredClone(message.contextFragment)
+    } : {}
+  };
+}
+function createAgentWorkflowTurnState(options) {
+  const pendingInput = options.initialInput ? cloneMessageSnapshot(options.initialInput) : void 0;
+  return {
+    sessionId: options.sessionId,
+    turnId: options.turnId,
+    systemPrompts: [...options.systemPrompts ?? []],
+    messages: (options.initialMessages ?? []).map(cloneMessageSnapshot),
+    phase: pendingInput ? "input-commit" : "model-step",
+    ...pendingInput ? { pendingInput } : {},
+    step: options.initialStep ?? 1,
+    maxSteps: options.maxSteps,
+    replayDecisions: {},
+    startedAt: options.startedAt,
+    updatedAt: options.startedAt
+  };
+}
+function cloneAgentWorkflowTurnState(state) {
+  return {
+    ...state,
+    systemPrompts: [...state.systemPrompts],
+    messages: state.messages.map(cloneMessageSnapshot),
+    ...state.pendingInput ? {
+      pendingInput: cloneMessageSnapshot(
+        state.pendingInput
+      )
+    } : {},
+    ...state.usage ? { usage: cloneUsage(state.usage) } : {},
+    ...state.turnState ? { turnState: structuredClone(state.turnState) } : {},
+    ...state.lastModelStep ? { lastModelStep: structuredClone(state.lastModelStep) } : {},
+    ...state.lastContextCompaction ? { lastContextCompaction: structuredClone(state.lastContextCompaction) } : {},
+    replayDecisions: Object.fromEntries(
+      Object.entries(state.replayDecisions).map(([toolCallId, decision]) => [
+        toolCallId,
+        { ...decision }
+      ])
+    ),
+    ...state.pendingInterventions?.length ? {
+      pendingInterventions: state.pendingInterventions.map(
+        (intervention) => ({ ...intervention })
+      )
+    } : {},
+    ...state.queuedFollowUps?.length ? {
+      queuedFollowUps: state.queuedFollowUps.map((intervention) => ({
+        ...intervention
+      }))
+    } : {}
+  };
+}
+function applyWorkflowInterventions(state, interventions, updatedAt) {
+  if (interventions.length === 0) {
+    return state;
+  }
+  const injected = interventions.map(
+    (intervention) => ({
+      id: intervention.id,
+      role: "user",
+      createdAt: intervention.createdAt,
+      content: intervention.message
+    })
+  );
+  return {
+    ...state,
+    messages: [...state.messages, ...injected],
+    pendingInterventions: void 0,
+    updatedAt
+  };
+}
+function drainWorkflowInterventions(state, updatedAt) {
+  if (!state.pendingInterventions?.length) {
+    return state;
+  }
+  return applyWorkflowInterventions(
+    state,
+    state.pendingInterventions,
+    updatedAt
+  );
+}
+function queueWorkflowFollowUps(state, followUps, updatedAt) {
+  if (followUps.length === 0) {
+    return state;
+  }
+  return {
+    ...state,
+    queuedFollowUps: [
+      ...state.queuedFollowUps ?? [],
+      ...followUps.map((followUp) => ({ ...followUp }))
+    ],
+    updatedAt
+  };
+}
+
+// src/execution/workflow/snapshot.ts
+function snapshotAgentWorkflowMessage(message) {
+  switch (message.role) {
+    case "user":
+      return {
+        id: message.id,
+        role: "user",
+        createdAt: message.createdAt.toISOString(),
+        content: message.content,
+        ...message.contextFragment ? { contextFragment: structuredClone(message.contextFragment) } : {},
+        ...message.system ? { system: message.system } : {}
+      };
+    case "assistant":
+      return {
+        id: message.id,
+        role: "assistant",
+        createdAt: message.createdAt.toISOString(),
+        content: message.content,
+        ...message.finish ? { finish: message.finish } : {},
+        ...message.tokens ? { tokens: { ...message.tokens } } : {},
+        ...message.cost !== void 0 ? { cost: message.cost } : {},
+        ...message.error ? { error: { ...message.error } } : {},
+        ...message.toolCalls ? {
+          toolCalls: message.toolCalls.map((toolCall) => ({
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            args: toolCall.args
+          }))
+        } : {}
+      };
+    case "tool":
+      return {
+        id: message.id,
+        role: "tool",
+        createdAt: message.createdAt.toISOString(),
+        content: message.content,
+        toolCallId: message.toolCallId,
+        toolName: message.toolName,
+        result: message.result,
+        ...message.metadata ? { metadata: structuredClone(message.metadata) } : {},
+        ...message.compactedAt !== void 0 ? { compactedAt: message.compactedAt } : {}
+      };
+    case "system":
+      return {
+        id: message.id,
+        role: "system",
+        createdAt: message.createdAt.toISOString(),
+        content: message.content,
+        ...message.contextFragment ? { contextFragment: structuredClone(message.contextFragment) } : {}
+      };
+  }
+}
+function snapshotAgentWorkflowMessages(messages) {
+  return messages.map((message) => snapshotAgentWorkflowMessage(message));
+}
+function restoreAgentWorkflowMessage(snapshot) {
+  const createdAt = new Date(snapshot.createdAt);
+  switch (snapshot.role) {
+    case "user":
+      return {
+        id: snapshot.id,
+        role: "user",
+        createdAt,
+        content: snapshot.content,
+        ...snapshot.contextFragment ? { contextFragment: structuredClone(snapshot.contextFragment) } : {},
+        ...snapshot.system ? { system: snapshot.system } : {}
+      };
+    case "assistant":
+      return {
+        id: snapshot.id,
+        role: "assistant",
+        createdAt,
+        content: snapshot.content,
+        ...snapshot.finish ? { finish: snapshot.finish } : {},
+        ...snapshot.tokens ? { tokens: { ...snapshot.tokens } } : {},
+        ...snapshot.cost !== void 0 ? { cost: snapshot.cost } : {},
+        ...snapshot.error ? { error: { ...snapshot.error } } : {},
+        ...snapshot.toolCalls ? {
+          toolCalls: snapshot.toolCalls.map((toolCall) => ({
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            args: toolCall.args
+          }))
+        } : {}
+      };
+    case "tool":
+      return {
+        id: snapshot.id,
+        role: "tool",
+        createdAt,
+        content: snapshot.content,
+        toolCallId: snapshot.toolCallId,
+        toolName: snapshot.toolName,
+        result: snapshot.result,
+        ...snapshot.metadata ? { metadata: structuredClone(snapshot.metadata) } : {},
+        ...snapshot.compactedAt !== void 0 ? { compactedAt: snapshot.compactedAt } : {}
+      };
+    case "system":
+      return {
+        id: snapshot.id,
+        role: "system",
+        createdAt,
+        content: snapshot.content,
+        ...snapshot.contextFragment ? { contextFragment: structuredClone(snapshot.contextFragment) } : {}
+      };
+  }
+}
+function restoreAgentWorkflowMessages(snapshots) {
+  return snapshots.map(restoreAgentWorkflowMessage);
+}
+
+// src/execution/workflow/planner/helpers.ts
+function cloneRelevantReplayDecisions(state, snapshot) {
+  return Object.fromEntries(
+    snapshot.toolCalls.flatMap((toolCall) => {
+      const decision = state.replayDecisions[toolCall.toolCallId];
+      return decision ? [[toolCall.toolCallId, { ...decision }]] : [];
+    })
+  );
+}
+function findAllUnresolvedToolCalls(snapshot) {
+  const resolvedIds = new Set(
+    snapshot.toolResults.map((toolResult) => toolResult.toolCallId)
+  );
+  return snapshot.toolCalls.filter(
+    (toolCall) => !resolvedIds.has(toolCall.toolCallId)
+  );
+}
+
+// src/execution/workflow/planner/plan.ts
+function planNextAgentWorkflowOperation(state) {
+  switch (state.phase) {
+    case "input-commit":
+      if (!state.pendingInput) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in input-commit phase without a pending input message`
+        );
+      }
+      return {
+        kind: "input-commit",
+        sessionId: state.sessionId,
+        messages: [structuredClone(state.pendingInput)]
+      };
+    case "model-step":
+      return {
+        kind: "model-step",
+        sessionId: state.sessionId,
+        turnId: state.turnId,
+        step: state.step,
+        maxSteps: state.maxSteps,
+        systemPrompts: [...state.systemPrompts],
+        messages: state.messages.map((message) => structuredClone(message)),
+        ...state.lastContextCompaction ? { contextCompaction: structuredClone(state.lastContextCompaction) } : {}
+      };
+    case "tool-batch": {
+      if (!state.lastModelStep?.stepCommit) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in tool-batch phase without a stepCommit snapshot`
+        );
+      }
+      const allUnresolved = findAllUnresolvedToolCalls(
+        state.lastModelStep.stepCommit
+      );
+      if (allUnresolved.length === 0) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in tool-batch phase without unresolved tool calls`
+        );
+      }
+      if (allUnresolved.length === 1) {
+        return {
+          kind: "tool-call",
+          step: state.step,
+          sessionId: state.sessionId,
+          toolCall: structuredClone(allUnresolved[0]),
+          turnState: state.turnState ? structuredClone(state.turnState) : void 0,
+          replayDecision: cloneRelevantReplayDecisions(
+            state,
+            state.lastModelStep.stepCommit
+          )[allUnresolved[0].toolCallId]
+        };
+      }
+      return {
+        kind: "tool-batch",
+        step: state.step,
+        sessionId: state.sessionId,
+        toolCalls: allUnresolved.map((tc) => structuredClone(tc)),
+        turnState: state.turnState ? structuredClone(state.turnState) : void 0,
+        replayDecisions: cloneRelevantReplayDecisions(
+          state,
+          state.lastModelStep.stepCommit
+        )
+      };
+    }
+    case "step-commit":
+      if (!state.lastModelStep?.stepCommit) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in step-commit phase without a stepCommit snapshot`
+        );
+      }
+      return {
+        kind: "step-commit",
+        sessionId: state.sessionId,
+        step: state.step,
+        snapshot: structuredClone(state.lastModelStep.stepCommit)
+      };
+    case "output-commit":
+      if (!state.lastModelStep) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in output-commit phase without a last model step`
+        );
+      }
+      return {
+        kind: "output-commit",
+        sessionId: state.sessionId,
+        text: state.lastModelStep.text,
+        ...state.lastModelStep.usage ? { usage: { ...state.lastModelStep.usage } } : {}
+      };
+    case "completed":
+    case "failed":
+      return void 0;
+  }
+}
+
+// src/execution/workflow/planner/apply.ts
+function applyAgentWorkflowContextCompactionResult(state, result, updatedAt) {
+  if (state.phase !== "model-step") {
+    throw new Error(
+      `Cannot apply context compaction while workflow state is in '${state.phase}' phase`
+    );
+  }
+  const next = cloneAgentWorkflowTurnState(state);
+  next.lastContextCompaction = {
+    applied: result.compacted,
+    phase: "pre-step",
+    inputTokens: result.inputTokens,
+    limit: result.limit,
+    decision: result.decision,
+    effectiveness: result.effectiveness,
+    removedCount: result.removedCount,
+    tokensRemoved: result.tokensRemoved,
+    summarized: result.summarized,
+    ...result.cutIndex !== void 0 ? { cutIndex: result.cutIndex } : {},
+    ...result.cutReason ? { cutReason: result.cutReason } : {}
+  };
+  if (result.compacted) {
+    next.messages = result.messages.map((message) => structuredClone(message));
+  }
+  next.updatedAt = updatedAt;
+  return next;
+}
+function applyAgentWorkflowModelStepResult(state, result, updatedAt) {
+  const next = cloneAgentWorkflowTurnState(state);
+  next.lastModelStep = structuredClone(result);
+  next.turnState = structuredClone(result.turnState);
+  next.usage = accumulateUsage(next.usage, result.usage);
+  next.updatedAt = updatedAt;
+  next.phase = result.finishReason === "tool-calls" ? "tool-batch" : "output-commit";
+  return next;
+}
+function applyAgentWorkflowToolBatchResult(state, result, updatedAt) {
+  if (state.phase !== "tool-batch") {
+    throw new Error(
+      `Cannot apply a tool-batch result while workflow state is in '${state.phase}' phase`
+    );
+  }
+  const next = cloneAgentWorkflowTurnState(state);
+  next.updatedAt = updatedAt;
+  next.phase = "step-commit";
+  if (!next.lastModelStep) {
+    throw new Error(
+      `Workflow state for session '${state.sessionId}' has no model step to update after tool-batch`
+    );
+  }
+  next.lastModelStep.stepCommit = structuredClone(result.stepCommit);
+  if (result.turnState) {
+    next.turnState = mergeAgentTurnStateProgress(
+      next.turnState,
+      result.turnState
+    );
+  }
+  return next;
+}
+function applyAgentWorkflowToolCallResult(state, result, updatedAt) {
+  if (state.phase !== "tool-batch") {
+    throw new Error(
+      `Cannot apply a tool-call result while workflow state is in '${state.phase}' phase`
+    );
+  }
+  if (!state.lastModelStep?.stepCommit) {
+    throw new Error(
+      `Workflow state for session '${state.sessionId}' has no stepCommit snapshot in tool-batch phase`
+    );
+  }
+  const next = cloneAgentWorkflowTurnState(state);
+  const snapshot = structuredClone(state.lastModelStep.stepCommit);
+  const existingResultIndex = snapshot.toolResults.findIndex(
+    (toolResult) => toolResult.toolCallId === result.toolResult.toolCallId
+  );
+  if (existingResultIndex >= 0) {
+    snapshot.toolResults[existingResultIndex] = structuredClone(
+      result.toolResult
+    );
+  } else {
+    snapshot.toolResults.push(structuredClone(result.toolResult));
+  }
+  next.lastModelStep = {
+    ...next.lastModelStep,
+    stepCommit: snapshot
+  };
+  next.updatedAt = updatedAt;
+  if (result.turnState) {
+    next.turnState = mergeAgentTurnStateProgress(
+      next.turnState,
+      result.turnState
+    );
+  }
+  next.phase = snapshot.toolResults.length >= snapshot.toolCalls.length ? "step-commit" : "tool-batch";
+  return next;
+}
+function applyAgentWorkflowCommitResult(state, result, updatedAt) {
+  const next = cloneAgentWorkflowTurnState(state);
+  next.messages = [
+    ...next.messages,
+    ...result.messages.map((message) => structuredClone(message))
+  ];
+  next.updatedAt = updatedAt;
+  switch (state.phase) {
+    case "input-commit":
+      next.phase = "model-step";
+      delete next.pendingInput;
+      return next;
+    case "step-commit":
+      next.step = state.step + 1;
+      next.phase = "model-step";
+      delete next.lastModelStep;
+      return next;
+    case "output-commit":
+      next.phase = "completed";
+      next.finalResponse = state.lastModelStep?.text ?? state.finalResponse;
+      delete next.lastModelStep;
+      return next;
+    default:
+      throw new Error(
+        `Cannot apply a commit result while workflow state is in '${state.phase}' phase`
+      );
+  }
+}
+function recordAgentWorkflowReplayDecision(state, decision, updatedAt) {
+  const next = cloneAgentWorkflowTurnState(state);
+  next.replayDecisions[decision.toolCallId] = { ...decision };
+  next.updatedAt = updatedAt;
+  return next;
+}
+function failAgentWorkflowTurnState(state, error, updatedAt) {
+  const next = cloneAgentWorkflowTurnState(state);
+  next.phase = "failed";
+  next.error = error.message;
+  next.updatedAt = updatedAt;
+  return next;
+}
+
+export {
+  createAgentWorkflowTurnState,
+  cloneAgentWorkflowTurnState,
+  applyWorkflowInterventions,
+  drainWorkflowInterventions,
+  queueWorkflowFollowUps,
+  snapshotAgentWorkflowMessage,
+  snapshotAgentWorkflowMessages,
+  restoreAgentWorkflowMessage,
+  restoreAgentWorkflowMessages,
+  planNextAgentWorkflowOperation,
+  applyAgentWorkflowContextCompactionResult,
+  applyAgentWorkflowModelStepResult,
+  applyAgentWorkflowToolBatchResult,
+  applyAgentWorkflowToolCallResult,
+  applyAgentWorkflowCommitResult,
+  recordAgentWorkflowReplayDecision,
+  failAgentWorkflowTurnState
+};