@skaile/workspaces 2.2.0 → 2.4.0

package/dist/{chunk-TQIU4HQG.js → chunk-2QVPCZTL.js}

@@ -1,16 +1,19 @@
-import { WorkspacePlugin } from './chunk-MAIKGYFR.js';
+import { WorkspacePlugin } from './chunk-AKVAZ5CB.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
 import { WebSocketServerTransport } from './chunk-WQ7DE5UC.js';
-import { EventNormalizer } from './chunk-RKMXBOIO.js';
+import { EventNormalizer } from './chunk-O7ROIKTF.js';
 import { SUPPORTED_CLOUDS, CLOUD_SECRET_ENV_KEYS } from './chunk-ISQWMBKD.js';
 import { classifyClaudeSdkError } from './chunk-GAH4YRCI.js';
-import { createDriver } from './chunk-KGIVZOLU.js';
+import { createDriver } from './chunk-GM2X24Q6.js';
+import { resolveFlowPath } from './chunk-6BV5NAPD.js';
 import { findAiAssetsRoot, deployCatalogEntry, undeployCatalogEntry } from './chunk-BEAIJRVF.js';
-import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, ConnectorStartupError, buildSdkConnectorTools, buildSdkFlowTools } from './chunk-6QSGCHE5.js';
+import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, ConnectorStartupError, buildSdkConnectorTools, SessionNodeExecutor, SessionInlineSubFlowRunner, buildSdkFlowTools } from './chunk-EEHOMCRU.js';
 import { loadConnectorDeclarations, SecretProviderChain, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, isKnownSecretRef, deriveSingleMaterializedConnectorDeclaration } from './chunk-ZNIHTT22.js';
-import { renderStimulusPrompt, buildOrchestratorPrompt } from './chunk-Y662DNQQ.js';
+import { loadFlow } from './chunk-4O2RAXKJ.js';
+import { parseFlowDefinition } from './chunk-OEGHKO5N.js';
+import { renderStimulusPrompt, buildOrchestratorPrompt } from './chunk-FKBQRV4J.js';
 import { PROTOCOL_VERSION } from './chunk-RDE43ORT.js';
-import { resolveSettings, resolveApiKey, providerEnvKey } from './chunk-63ZPKREA.js';
+import { resolveSettings, resolveApiKey, providerEnvKey } from './chunk-P43HBWKK.js';
 import { resolveDriverPaths } from './chunk-K5GBV4SA.js';
 import { resolveRuntimeAssets } from './chunk-UFY2HFLO.js';
 import { resolveSkWorkspaceConfig, resolveAgentDir, cloudConfigFromProfile, stageMaterializedSkills, loadMcpServerDeclarations, COMPACTION_DEFAULTS, validateAssetRecipeAttr, deriveSingleMaterializedMcpDeclaration } from './chunk-Q26C5GLO.js';
@@ -4443,26 +4446,36 @@ function buildConnectorTokenMediator(deps) {
     }
   };
 }
+function normalizeFlowMutateDefinition(authored) {
+  const parsed = parseFlowDefinition(authored);
+  if (parsed.ok) return { ok: true, flowDef: parsed.data };
+  const details = parsed.errors.map((issue) => `${issue.path || "<root>"}: ${issue.message}`).join("; ");
+  return { ok: false, reason: `invalid flow definition: ${details}` };
+}
 function planFlowMutate(cmd, ctx) {
   const isBareFlowId = cmd.id === "flow";
   const flowIntercept = ctx.isExistingFlow || isBareFlowId;
   const payload = cmd.payload ?? {};
   if (cmd.op === "start" && flowIntercept) {
-    const flowDef = payload.flow;
+    const authoredFlow = payload.flow;
     const seed = payload.seed;
-    if (!flowDef?.id || !seed?.runId || !seed?.startedBy) {
+    if (!authoredFlow || !seed?.runId || !seed?.startedBy) {
       return {
         kind: "reject",
         reason: "flow.start payload missing required fields (need payload.flow.id, payload.seed.runId, payload.seed.startedBy)"
       };
     }
+    const normalized = normalizeFlowMutateDefinition(authoredFlow);
+    if (!normalized.ok) {
+      return { kind: "reject", reason: `flow.start ${normalized.reason}` };
+    }
     if (ctx.hasRunningFlow) {
       return {
         kind: "reject",
         reason: "flow.start ignored: a flow is still running (one active flow per session; cancel it, then start the next)"
       };
     }
-    return { kind: "create-start", flowDef, seed };
+    return { kind: "create-start", flowDef: normalized.flowDef, seed };
   }
   if (cmd.op === "hydrate" && flowIntercept && !ctx.hasActiveFlow) {
     const state = payload.state;
@@ -4472,14 +4485,18 @@ function planFlowMutate(cmd, ctx) {
         reason: "flow.hydrate payload missing required field payload.state (FlowExecution snapshot)"
       };
     }
-    const flowDef = payload.flow;
-    if (!flowDef?.id) {
+    const authoredFlow = payload.flow;
+    if (!authoredFlow) {
       return {
         kind: "reject",
         reason: "flow.hydrate cannot bootstrap a cold container without payload.flow (FlowDefinition required when no flow is active)"
       };
     }
-    return { kind: "create-hydrate", flowDef, execution: state };
+    const normalized = normalizeFlowMutateDefinition(authoredFlow);
+    if (!normalized.ok) {
+      return { kind: "reject", reason: `flow.hydrate ${normalized.reason}` };
+    }
+    return { kind: "create-hydrate", flowDef: normalized.flowDef, execution: state };
   }
   let dispatchId = cmd.id;
   if (!ctx.targetExists && isBareFlowId && ctx.onlyActiveConnectorId) {
@@ -4636,6 +4653,11 @@ function pendingDecisionOp(decision) {
     }
   };
 }
+function hasRejectedParkedApproval(execution) {
+  return Object.values(execution.nodes ?? {}).some(
+    (node) => node.status === "awaiting_approval" && node.approval?.decision === "rejected" && node.approval.decidedAt != null
+  );
+}
 function hostOpResumeStimulus(op, payload) {
   switch (op) {
     case "applyApproval":
@@ -4733,21 +4755,23 @@ async function executeConnectorMutate(cmd, deps) {
         });
         if (payload.pendingDecisions === void 0) {
           respond({ ok: true });
+          if (entry.hydratedStateChanged || hasRejectedParkedApproval(plan.execution)) {
+            deps.signalStimulus(entry, { kind: "resumed_after_hibernation" });
+          }
           return;
         }
         const { toApply, reconciled } = reconcilePendingDecisions(
           plan.execution,
           payload.pendingDecisions
         );
-        let lastApplied = null;
+        let appliedAny = false;
         const applied = [];
         for (const decision of toApply) {
           const { op, payload: opPayload } = pendingDecisionOp(decision);
           try {
             await deps.executeOp(entry.connectorId, op, opPayload);
             applied.push(decision.nodeId);
-            const stimulus = hostOpResumeStimulus(op, opPayload);
-            if (stimulus) lastApplied = { target: entry, stimulus };
+            appliedAny = true;
           } catch (err) {
             reconciled.skipped.push({ nodeId: decision.nodeId, reason: "not_parked" });
             deps.log.warn("flow hydrate reconciliation refused", {
@@ -4759,7 +4783,9 @@ async function executeConnectorMutate(cmd, deps) {
         }
         reconciled.applied = applied;
         respond({ ok: true, reconciled });
-        if (lastApplied) deps.signalStimulus(lastApplied.target, lastApplied.stimulus);
+        if (appliedAny || entry.hydratedStateChanged || hasRejectedParkedApproval(plan.execution)) {
+          deps.signalStimulus(entry, { kind: "resumed_after_hibernation" });
+        }
         return;
       }
       case "reject": {
@@ -4789,6 +4815,9 @@ async function executeConnectorMutate(cmd, deps) {
         if (resumeStimulus) {
           const active = deps.flowState().activeFlow;
           if (active) deps.signalStimulus(active, resumeStimulus);
+        } else if (cmd.op === "hydrate" && typeof result === "string" && JSON.stringify(payload.state) !== result) {
+          const active = deps.flowState().activeFlow;
+          if (active) deps.signalStimulus(active, { kind: "resumed_after_hibernation" });
         }
         return;
       }
@@ -4803,6 +4832,8 @@ function reconstructTypedStimulus(meta) {
   switch (meta.kind) {
     case "flow_started":
       return { kind: "flow_started" };
+    case "resumed_after_hibernation":
+      return { kind: "resumed_after_hibernation" };
     case "user_message":
       return typeof meta.text === "string" ? {
         kind: "user_message",
@@ -5375,6 +5406,19 @@ async function startAgentServer(opts) {
   }
   const flowConnectorReadiness = createFlowConnectorReadiness(() => getOnlyActiveFlow() !== null);
   const flowMutateConnectorWaitMs = resolveFlowMutateConnectorWaitMs();
+  async function ensureFlowDriverStarted() {
+    if (driverStarted) return;
+    await driver.start();
+    driverStarted = true;
+    driver.on("agent-event", (event) => {
+      const normalized = normalizer.normalize(event);
+      for (const e of normalized) forwardNormalizedEvent(e);
+    });
+    driver.on("error", (err) => {
+      log(`[serve] driver error: ${err.message}`);
+      sendEvent({ type: "error", message: err.message, fatal: true });
+    });
+  }
   function getOrCreateStimulusBus() {
     if (stimulusBus) return stimulusBus;
     stimulusBus = createSessionStimulusBus({
@@ -5387,23 +5431,14 @@ async function startAgentServer(opts) {
           return;
         }
         const stimulus = stimulusFromMetas(metas);
-        const fullPrompt = buildOrchestratorPrompt(
-          entry.flowDef,
-          entry.adapter.getExecution(entry.handle),
-          stimulus
-        );
-        if (!driverStarted) {
-          await driver.start();
-          driverStarted = true;
-          driver.on("agent-event", (event) => {
-            const normalized = normalizer.normalize(event);
-            for (const e of normalized) forwardNormalizedEvent(e);
-          });
-          driver.on("error", (err) => {
-            log(`[serve] driver error: ${err.message}`);
-            sendEvent({ type: "error", message: err.message, fatal: true });
-          });
+        await entry.adapter.drainRuntimeNodes(entry.handle);
+        const execution = entry.adapter.getExecution(entry.handle);
+        if (execution.done || execution.status === "failed" || execution.status === "cancelled") {
+          return;
         }
+        if (!entry.adapter.shouldDriveAgentTurn(entry.handle, stimulus)) return;
+        const fullPrompt = buildOrchestratorPrompt(entry.flowDef, execution, stimulus);
+        await ensureFlowDriverStarted();
         await awaitFlowAgentEnd(fullPrompt, FLOW_TURN_TIMEOUT_MS);
       },
       log: serverLog
@@ -5461,9 +5496,23 @@ async function startAgentServer(opts) {
   }
   async function createActiveFlow(flowDef, seedOrExecution) {
     const bus = getOrCreateStimulusBus();
+    const nodeExecutor = new SessionNodeExecutor({ workspaceDir: opts.projectDir });
+    const inlineSubFlowRunner = new SessionInlineSubFlowRunner({
+      resolveFlow: (flowId) => loadFlow(resolveFlowPath(flowId, opts.projectDir)),
+      nodeExecutor,
+      driveAgentTurn: async ({ flow, execution, stimulus }) => {
+        await ensureFlowDriverStarted();
+        await awaitFlowAgentEnd(
+          buildOrchestratorPrompt(flow, execution, stimulus),
+          FLOW_TURN_TIMEOUT_MS
+        );
+      }
+    });
     const baseOptions = {
       stimulusBus: bus,
-      useBusForStimulus: true
+      useBusForStimulus: true,
+      nodeExecutor,
+      inlineSubFlowRunner
     };
     const options = "execution" in seedOrExecution ? { flow: flowDef, execution: seedOrExecution.execution, ...baseOptions } : { flow: flowDef, seed: seedOrExecution.seed, ...baseOptions };
     const seedRunId = "execution" in seedOrExecution ? seedOrExecution.execution.runId : seedOrExecution.seed.runId;
@@ -5480,6 +5529,7 @@ async function startAgentServer(opts) {
     });
     const adapter = manager.get(connectorId).connector;
     const runId = adapter.getExecution(handle).runId;
+    const hydratedStateChanged = "execution" in seedOrExecution && JSON.stringify(adapter.getExecution(handle)) !== JSON.stringify(seedOrExecution.execution);
     adapter.onStateChange(handle, (state) => {
       sendEvent({
         type: "state_changed",
@@ -5487,7 +5537,7 @@ async function startAgentServer(opts) {
         state
       });
     });
-    if ("seed" in seedOrExecution) {
+    if ("seed" in seedOrExecution || hydratedStateChanged) {
       sendEvent({
         type: "state_changed",
         store: `flow:${runId}`,
@@ -5495,9 +5545,9 @@ async function startAgentServer(opts) {
       });
     }
     driver.config.flowTestDriver = {
-      getState: () => adapter.getExecution(handle),
+      getState: () => adapter.getAgentExecution(handle),
       execute: (op, args) => adapter.executeOp(handle, op, args),
-      mandatoryGates: () => adapter.getMandatoryGates(handle)
+      mandatoryGates: () => adapter.getMandatoryAgentApprovalNodeIds(handle)
     };
     if (agentSession?.driverType === "claude-sdk") {
       try {
@@ -5517,7 +5567,14 @@ async function startAgentServer(opts) {
       }
     }
     emitAvailability();
-    const entry = { runId, flowDef, adapter, handle, connectorId };
+    const entry = {
+      runId,
+      flowDef,
+      adapter,
+      handle,
+      connectorId,
+      hydratedStateChanged
+    };
     const pruned = registerActiveFlow(activeFlows, runId, entry);
     if (pruned.length > 0) serverLog.debug("pruned terminal flow runs", { runIds: pruned });
     flowConnectorReadiness.drain();
@@ -6232,7 +6289,11 @@ async function startAgentServer(opts) {
       },
       createActiveFlow: async (flowDef, seedOrExecution) => {
         const entry = await createActiveFlow(flowDef, seedOrExecution);
-        return { runId: entry.runId, connectorId: entry.connectorId };
+        return {
+          runId: entry.runId,
+          connectorId: entry.connectorId,
+          hydratedStateChanged: entry.hydratedStateChanged
+        };
       },
       waitForFlowConnector: (timeoutMs, isSatisfied) => flowConnectorReadiness.wait(timeoutMs, isSatisfied),
       connectorWaitMs: flowMutateConnectorWaitMs,
@@ -6702,5 +6763,5 @@ function touchSession(state) {
 }
 
 export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createSessionStimulusBus, defineCapability, deleteSession, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadSession, loadSessionById, mcpAuthSecretKey, newSession, pickRepointedManager, planFlowMutate, reconcilePendingDecisions, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-TQIU4HQG.js.map
-//# sourceMappingURL=chunk-TQIU4HQG.js.map
+//# sourceMappingURL=chunk-2QVPCZTL.js.map
+//# sourceMappingURL=chunk-2QVPCZTL.js.map