@contractspec/integration.workflow-devkit 0.1.3 → 0.1.5

package/dist/node/index.js

@@ -1,285 +1,7 @@
-// src/agent-adapter.ts
-class InMemoryWorkflowDevkitCheckpointStore {
-  envelopes = new Map;
-  async delete(sessionId) {
-    this.envelopes.delete(sessionId);
-  }
-  async load(sessionId) {
-    return this.envelopes.get(sessionId) ?? null;
-  }
-  async save(envelope) {
-    this.envelopes.set(envelope.sessionId, envelope);
-  }
-}
-
-class InMemoryWorkflowDevkitSuspensionStore {
-  states = new Map;
-  async clear(sessionId) {
-    this.states.delete(sessionId);
-  }
-  async get(sessionId) {
-    return this.states.get(sessionId) ?? null;
-  }
-  async set(sessionId, state) {
-    this.states.set(sessionId, state);
-  }
-}
-function createWorkflowDevkitAgentRuntimeAdapterBundle(options = {}) {
-  const checkpointStore = options.checkpointStore ?? new InMemoryWorkflowDevkitCheckpointStore;
-  const suspensionStore = options.suspensionStore ?? new InMemoryWorkflowDevkitSuspensionStore;
-  const resolveSessionToken = options.resolveSessionToken ?? defaultWorkflowDevkitAgentToken;
-  return {
-    key: "workflow-devkit",
-    checkpoint: {
-      delete(sessionId) {
-        return checkpointStore.delete(sessionId);
-      },
-      load(sessionId) {
-        return checkpointStore.load(sessionId);
-      },
-      save(envelope) {
-        return checkpointStore.save(envelope);
-      }
-    },
-    suspendResume: {
-      async resume(params) {
-        await suspensionStore.set(params.sessionId, {
-          input: params.input,
-          metadata: params.metadata,
-          reason: "resumed",
-          resumedAt: new Date,
-          suspendedAt: new Date
-        });
-        if (options.workflowApi) {
-          await options.workflowApi.resumeHook(resolveSessionToken(params.sessionId), {
-            input: params.input,
-            metadata: params.metadata,
-            sessionId: params.sessionId
-          });
-        }
-      },
-      async suspend(params) {
-        await suspensionStore.set(params.sessionId, {
-          metadata: params.metadata,
-          reason: params.reason,
-          suspendedAt: new Date
-        });
-      }
-    }
-  };
-}
-function defaultWorkflowDevkitAgentToken(sessionId) {
-  return `agent-session:${sessionId}`;
-}
-
-// src/chat-routes.ts
-import { createUIMessageStreamResponse } from "ai";
-import { getRun, resumeHook, start } from "workflow/api";
-var WORKFLOW_RUN_ID_HEADER = "x-workflow-run-id";
-var WORKFLOW_STREAM_TAIL_INDEX_HEADER = "x-workflow-stream-tail-index";
-function createWorkflowDevkitStartRoute(options) {
-  const workflowApi = options.workflowApi ?? { start };
-  return async (request) => {
-    const body = await request.json();
-    const args = await options.buildArgs(body, request);
-    const run = await workflowApi.start(options.workflow, args);
-    if (options.createResponse) {
-      return options.createResponse({ body, run });
-    }
-    if (!run.readable) {
-      return new Response(JSON.stringify({ runId: run.runId }), {
-        headers: {
-          "Content-Type": "application/json",
-          [WORKFLOW_RUN_ID_HEADER]: run.runId
-        }
-      });
-    }
-    return createUIMessageStreamResponse({
-      headers: {
-        [WORKFLOW_RUN_ID_HEADER]: run.runId
-      },
-      stream: run.readable
-    });
-  };
-}
-function createWorkflowDevkitFollowUpRoute(options) {
-  const workflowApi = options.workflowApi ?? { resumeHook };
-  return async (request, context) => {
-    const runId = context.params.runId ?? context.params.id;
-    if (!runId) {
-      return new Response(JSON.stringify({ error: "Missing run id" }), {
-        status: 400
-      });
-    }
-    const body = await request.json();
-    const token = options.resolveToken({ body, request, runId });
-    const payload = options.buildPayload ? await options.buildPayload(body, request) : body;
-    await workflowApi.resumeHook(token, payload);
-    return new Response(JSON.stringify({ ok: true }), {
-      headers: {
-        "Content-Type": "application/json",
-        [WORKFLOW_RUN_ID_HEADER]: runId
-      }
-    });
-  };
-}
-function createWorkflowDevkitStreamRoute(options = {}) {
-  const workflowApi = options.workflowApi ?? { getRun };
-  return async (request, context) => {
-    const runId = context.params.runId ?? context.params.id;
-    if (!runId) {
-      return new Response(JSON.stringify({ error: "Missing run id" }), {
-        status: 400
-      });
-    }
-    const run = workflowApi.getRun(runId);
-    if (!run) {
-      return new Response(JSON.stringify({ error: "Workflow run not found" }), {
-        status: 404
-      });
-    }
-    const startIndex = readStartIndex(request.url);
-    const readable = run.getReadable ? run.getReadable({ startIndex }) : run.readable;
-    if (!readable) {
-      return new Response(JSON.stringify({ error: "Run has no readable stream" }), {
-        status: 404
-      });
-    }
-    const tailIndex = await readable.getTailIndex?.();
-    return createUIMessageStreamResponse({
-      headers: {
-        ...tailIndex !== undefined ? {
-          [WORKFLOW_STREAM_TAIL_INDEX_HEADER]: String(tailIndex)
-        } : {}
-      },
-      stream: readable
-    });
-  };
-}
-function readStartIndex(url) {
-  const parsed = new URL(url);
-  const rawStartIndex = parsed.searchParams.get("startIndex");
-  if (!rawStartIndex) {
-    return;
-  }
-  const parsedStartIndex = Number(rawStartIndex);
-  return Number.isFinite(parsedStartIndex) ? parsedStartIndex : undefined;
-}
+class Y{envelopes=new Map;async delete(C){this.envelopes.delete(C)}async load(C){return this.envelopes.get(C)??null}async save(C){this.envelopes.set(C.sessionId,C)}}class Z{states=new Map;async clear(C){this.states.delete(C)}async get(C){return this.states.get(C)??null}async set(C,_){this.states.set(C,_)}}function F(C={}){let _=C.checkpointStore??new Y,H=C.suspensionStore??new Z,A=C.resolveSessionToken??M;return{key:"workflow-devkit",checkpoint:{delete(O){return _.delete(O)},load(O){return _.load(O)},save(O){return _.save(O)}},suspendResume:{async resume(O){if(await H.set(O.sessionId,{input:O.input,metadata:O.metadata,reason:"resumed",resumedAt:new Date,suspendedAt:new Date}),C.workflowApi)await C.workflowApi.resumeHook(A(O.sessionId),{input:O.input,metadata:O.metadata,sessionId:O.sessionId})},async suspend(O){await H.set(O.sessionId,{metadata:O.metadata,reason:O.reason,suspendedAt:new Date})}}}}function M(C){return`agent-session:${C}`}import{createUIMessageStreamResponse as P}from"ai";import{getRun as f,resumeHook as h,start as N}from"workflow/api";var Q="x-workflow-run-id",B="x-workflow-stream-tail-index";function g(C){let _=C.workflowApi??{start:N};return async(H)=>{let A=await H.json(),O=await C.buildArgs(A,H),K=await _.start(C.workflow,O);if(C.createResponse)return C.createResponse({body:A,run:K});if(!K.readable)return new Response(JSON.stringify({runId:K.runId}),{headers:{"Content-Type":"application/json",[Q]:K.runId}});return P({headers:{[Q]:K.runId},stream:K.readable})}}function S(C){let _=C.workflowApi??{resumeHook:h};return async(H,A)=>{let O=A.params.runId??A.params.id;if(!O)return new Response(JSON.stringify({error:"Missing run id"}),{status:400});let K=await H.json(),L=C.resolveToken({body:K,request:H,runId:O}),W=C.buildPayload?await C.buildPayload(K,H):K;return await _.resumeHook(L,W),new Response(JSON.stringify({ok:!0}),{headers:{"Content-Type":"application/json",[Q]:O}})}}function y(C={}){let _=C.workflowApi??{getRun:f};return async(H,A)=>{let O=A.params.runId??A.params.id;if(!O)return new Response(JSON.stringify({error:"Missing run id"}),{status:400});let K=_.getRun(O);if(!K)return new Response(JSON.stringify({error:"Workflow run not found"}),{status:404});let L=w(H.url),W=K.getReadable?K.getReadable({startIndex:L}):K.readable;if(!W)return new Response(JSON.stringify({error:"Run has no readable stream"}),{status:404});let j=await W.getTailIndex?.();return P({headers:{...j!==void 0?{[B]:String(j)}:{}},stream:W})}}function w(C){let H=new URL(C).searchParams.get("startIndex");if(!H)return;let A=Number(H);return Number.isFinite(A)?A:void 0}import{evaluateExpression as b}from"@contractspec/lib.contracts-spec/workflow/expression";function R(C){return C.runtime?.workflowDevkit?.behavior??C.type}function U(C){let _=C.definition.entryStepId??C.definition.steps[0]?.id;if(!_)throw Error(`Workflow ${C.meta.key}.v${C.meta.version} does not define an entry step.`);return _}function v(C,_){if(_)return _;let H=C.runtime?.workflowDevkit?.runIdentity?.strategy??"meta-key-version",A=C.runtime?.workflowDevkit?.runIdentity?.prefix,O=H==="meta-key-version"?`${C.meta.key}.v${C.meta.version}`:`${C.meta.key}.v${C.meta.version}`;return A?`${A}:${O}`:O}function V(C,_,H){let A=_.runtime?.workflowDevkit;if(!A)return;let O=A.hookWait?.token??A.webhookWait?.token??A.approvalWait?.token??A.streamSession?.followUpToken;if(O)return O;let K=C.runtime?.workflowDevkit?.hookTokens?.strategy??"deterministic",L=C.runtime?.workflowDevkit?.hookTokens?.prefix??C.meta.key,W=D(_.id);if(K==="session-scoped"){let j=D(v(C,H));return`${L}:${j}:${W}`}if(K==="step-scoped")return`${L}:v${C.meta.version}:${W}`;return`${L}:${W}`}function E(C,_,H,A,O){let K=C.definition.transitions.filter((L)=>L.from===_.id);for(let L of K)if(b(L.condition,{data:H,input:A,output:O}))return L.to;return null}function z(C,_,H){let A={...C};if(T(_))Object.assign(A,_);if(T(H))Object.assign(A,H);return A}function D(C){return C.replace(/[^a-zA-Z0-9_-]+/g,"-")}function T(C){return C!=null&&typeof C==="object"&&!Array.isArray(C)}function q(C){return{entryStepId:U(C),hostTarget:C.runtime?.workflowDevkit?.hostTarget??"generic",hookTokenStrategy:C.runtime?.workflowDevkit?.hookTokens?.strategy??"deterministic",integrationMode:C.runtime?.workflowDevkit?.integrationMode??"manual",runIdentityStrategy:C.runtime?.workflowDevkit?.runIdentity?.strategy??"meta-key-version",specKey:C.meta.key,specVersion:C.meta.version,steps:C.definition.steps.map((_)=>({behavior:R(_),id:_.id,label:_.label,operationRef:_.action?.operation?`${_.action.operation.key}.v${_.action.operation.version}`:void 0,runtime:_.runtime?.workflowDevkit,transitions:C.definition.transitions.filter((H)=>H.from===_.id).map((H)=>({condition:H.condition,to:H.to})),type:_.type,waitToken:V(C,_)}))}}function k(C,_){let H=q(C),A=_.workflowFunctionName??`${D(_.exportName)}WorkflowDevkit`;return{genericBootstrap:l(_.exportName,A),manifest:JSON.stringify(H,null,2),nextFollowUpRoute:m(A),nextStartRoute:I(A),nextStreamRoute:x(),workflowModule:d(_.exportName,_.specImportPath,A)}}function l(C,_){return`import { ${_} } from "./${D(C)}.workflow-devkit";
 
-// src/helpers.ts
-import { evaluateExpression } from "@contractspec/lib.contracts-spec/workflow/expression";
-function inferWorkflowDevkitBehavior(step) {
-  return step.runtime?.workflowDevkit?.behavior ?? step.type;
-}
-function resolveWorkflowDevkitEntryStepId(spec) {
-  const entryStepId = spec.definition.entryStepId ?? spec.definition.steps[0]?.id;
-  if (!entryStepId) {
-    throw new Error(`Workflow ${spec.meta.key}.v${spec.meta.version} does not define an entry step.`);
-  }
-  return entryStepId;
-}
-function resolveWorkflowDevkitRunIdentity(spec, runIdentity) {
-  if (runIdentity) {
-    return runIdentity;
-  }
-  const strategy = spec.runtime?.workflowDevkit?.runIdentity?.strategy ?? "meta-key-version";
-  const prefix = spec.runtime?.workflowDevkit?.runIdentity?.prefix;
-  const baseIdentity = strategy === "meta-key-version" ? `${spec.meta.key}.v${spec.meta.version}` : `${spec.meta.key}.v${spec.meta.version}`;
-  return prefix ? `${prefix}:${baseIdentity}` : baseIdentity;
-}
-function resolveWorkflowDevkitWaitToken(spec, step, runIdentity) {
-  const runtime = step.runtime?.workflowDevkit;
-  if (!runtime) {
-    return;
-  }
-  const explicitToken = runtime.hookWait?.token ?? runtime.webhookWait?.token ?? runtime.approvalWait?.token ?? runtime.streamSession?.followUpToken;
-  if (explicitToken) {
-    return explicitToken;
-  }
-  const tokenStrategy = spec.runtime?.workflowDevkit?.hookTokens?.strategy ?? "deterministic";
-  const prefix = spec.runtime?.workflowDevkit?.hookTokens?.prefix ?? spec.meta.key;
-  const stableStepId = sanitizeIdentifier(step.id);
-  if (tokenStrategy === "session-scoped") {
-    const resolvedRunIdentity = sanitizeIdentifier(resolveWorkflowDevkitRunIdentity(spec, runIdentity));
-    return `${prefix}:${resolvedRunIdentity}:${stableStepId}`;
-  }
-  if (tokenStrategy === "step-scoped") {
-    return `${prefix}:v${spec.meta.version}:${stableStepId}`;
-  }
-  return `${prefix}:${stableStepId}`;
-}
-function resolveWorkflowDevkitNextStepId(spec, step, data, input, output) {
-  const transitions = spec.definition.transitions.filter((transition) => transition.from === step.id);
-  for (const transition of transitions) {
-    if (evaluateExpression(transition.condition, {
-      data,
-      input,
-      output
-    })) {
-      return transition.to;
-    }
-  }
-  return null;
-}
-function mergeWorkflowDevkitData(current, input, output) {
-  const next = { ...current };
-  if (isRecord(input)) {
-    Object.assign(next, input);
-  }
-  if (isRecord(output)) {
-    Object.assign(next, output);
-  }
-  return next;
-}
-function sanitizeIdentifier(value) {
-  return value.replace(/[^a-zA-Z0-9_-]+/g, "-");
-}
-function isRecord(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value);
-}
-
-// src/compiler.ts
-function compileWorkflowSpecToWorkflowDevkit(spec) {
-  return {
-    entryStepId: resolveWorkflowDevkitEntryStepId(spec),
-    hostTarget: spec.runtime?.workflowDevkit?.hostTarget ?? "generic",
-    hookTokenStrategy: spec.runtime?.workflowDevkit?.hookTokens?.strategy ?? "deterministic",
-    integrationMode: spec.runtime?.workflowDevkit?.integrationMode ?? "manual",
-    runIdentityStrategy: spec.runtime?.workflowDevkit?.runIdentity?.strategy ?? "meta-key-version",
-    specKey: spec.meta.key,
-    specVersion: spec.meta.version,
-    steps: spec.definition.steps.map((step) => ({
-      behavior: inferWorkflowDevkitBehavior(step),
-      id: step.id,
-      label: step.label,
-      operationRef: step.action?.operation ? `${step.action.operation.key}.v${step.action.operation.version}` : undefined,
-      runtime: step.runtime?.workflowDevkit,
-      transitions: spec.definition.transitions.filter((transition) => transition.from === step.id).map((transition) => ({
-        condition: transition.condition,
-        to: transition.to
-      })),
-      type: step.type,
-      waitToken: resolveWorkflowDevkitWaitToken(spec, step)
-    }))
-  };
-}
-function generateWorkflowDevkitArtifacts(spec, options) {
-  const compilation = compileWorkflowSpecToWorkflowDevkit(spec);
-  const workflowFunctionName = options.workflowFunctionName ?? `${sanitizeIdentifier(options.exportName)}WorkflowDevkit`;
-  return {
-    genericBootstrap: createGenericBootstrapTemplate(options.exportName, workflowFunctionName),
-    manifest: JSON.stringify(compilation, null, 2),
-    nextFollowUpRoute: createFollowUpRouteTemplate(workflowFunctionName),
-    nextStartRoute: createStartRouteTemplate(workflowFunctionName),
-    nextStreamRoute: createStreamRouteTemplate(),
-    workflowModule: createWorkflowModuleTemplate(options.exportName, options.specImportPath, workflowFunctionName)
-  };
-}
-function createGenericBootstrapTemplate(exportName, workflowFunctionName) {
-  return `import { ${workflowFunctionName} } from "./${sanitizeIdentifier(exportName)}.workflow-devkit";
-
-export const ${sanitizeIdentifier(exportName)}WorkflowDevkitBootstrap = {
-  workflow: ${workflowFunctionName},
+export const ${D(C)}WorkflowDevkitBootstrap = {
+  workflow: ${_},
   createBridge() {
     return {
       executeAutomationStep: async () => {
@@ -288,49 +10,37 @@ export const ${sanitizeIdentifier(exportName)}WorkflowDevkitBootstrap = {
     };
   },
 };
-`;
-}
-function createStartRouteTemplate(workflowFunctionName) {
-  return `import { createWorkflowDevkitStartRoute } from "@contractspec/integration.workflow-devkit";
-import { ${workflowFunctionName} } from "./workflow";
+`}function I(C){return`import { createWorkflowDevkitStartRoute } from "@contractspec/integration.workflow-devkit";
+import { ${C} } from "./workflow";
 
 export const POST = createWorkflowDevkitStartRoute({
-  workflow: ${workflowFunctionName},
+  workflow: ${C},
   async buildArgs(body) {
     return [body];
   },
 });
-`;
-}
-function createFollowUpRouteTemplate(workflowFunctionName) {
-  return `import { createWorkflowDevkitFollowUpRoute } from "@contractspec/integration.workflow-devkit";
+`}function m(C){return`import { createWorkflowDevkitFollowUpRoute } from "@contractspec/integration.workflow-devkit";
 
 export const POST = createWorkflowDevkitFollowUpRoute({
   resolveToken({ runId }) {
-    return \`${workflowFunctionName}:\${runId}\`;
+    return \`${C}:\${runId}\`;
   },
 });
-`;
-}
-function createStreamRouteTemplate() {
-  return `import { createWorkflowDevkitStreamRoute } from "@contractspec/integration.workflow-devkit";
+`}function x(){return`import { createWorkflowDevkitStreamRoute } from "@contractspec/integration.workflow-devkit";
 
 export const GET = createWorkflowDevkitStreamRoute();
-`;
-}
-function createWorkflowModuleTemplate(exportName, specImportPath, workflowFunctionName) {
-  return `import { createHook, createWebhook, sleep } from "workflow";
+`}function d(C,_,H){return`import { createHook, createWebhook, sleep } from "workflow";
 import { runWorkflowSpecWithWorkflowDevkit } from "@contractspec/integration.workflow-devkit";
-import { ${exportName} } from "${specImportPath}";
+import { ${C} } from "${_}";
 
-export async function ${workflowFunctionName}(input = {}, bridge = {}) {
+export async function ${H}(input = {}, bridge = {}) {
   "use workflow";
 
   // Keep the workflow function deterministic.
   // Any Node.js or side-effectful logic should live in "use step" helpers that
   // your bridge calls, not in this orchestrator itself.
   return runWorkflowSpecWithWorkflowDevkit({
-    spec: ${exportName},
+    spec: ${C},
     initialData: input,
     bridge,
     primitives: {
@@ -340,143 +50,4 @@ export async function ${workflowFunctionName}(input = {}, bridge = {}) {
     },
   });
 }
-`;
-}
-
-// src/next.ts
-import { withWorkflow } from "workflow/next";
-function withContractSpecWorkflow(nextConfig) {
-  return withWorkflow(nextConfig);
-}
-
-// src/runtime.ts
-async function runWorkflowSpecWithWorkflowDevkit(options) {
-  const history = [];
-  let currentStepId = resolveWorkflowDevkitEntryStepId(options.spec);
-  let data = { ...options.initialData ?? {} };
-  let input = options.initialData;
-  while (currentStepId) {
-    const step = lookupStep(options.spec, currentStepId);
-    const runtime = step.runtime?.workflowDevkit;
-    const context = {
-      data,
-      input,
-      runIdentity: options.runIdentity,
-      runtime,
-      spec: options.spec,
-      step
-    };
-    const behavior = inferWorkflowDevkitBehavior(step);
-    const token = resolveWorkflowDevkitWaitToken(options.spec, step, options.runIdentity);
-    const output = await executeWorkflowDevkitBehavior(behavior, context, token, options.bridge, options.primitives);
-    history.push({
-      behavior,
-      input,
-      output,
-      stepId: step.id,
-      token
-    });
-    data = mergeWorkflowDevkitData(data, input, output);
-    const nextStepId = resolveWorkflowDevkitNextStepId(options.spec, step, data, input, output);
-    if (!nextStepId) {
-      return {
-        currentStep: null,
-        data,
-        history,
-        status: "completed"
-      };
-    }
-    currentStepId = nextStepId;
-    input = output;
-  }
-  return {
-    currentStep: null,
-    data,
-    history,
-    status: "completed"
-  };
-}
-async function executeWorkflowDevkitBehavior(behavior, context, token, bridge, primitives) {
-  switch (behavior) {
-    case "sleep":
-      if (!context.runtime?.sleep?.duration) {
-        throw new Error(`Step "${context.step.id}" is missing sleep.duration.`);
-      }
-      await primitives.sleep(context.runtime.sleep.duration);
-      return { sleptFor: context.runtime.sleep.duration };
-    case "hookWait":
-      return awaitExternalWait(context, token, bridge?.onExternalWait, primitives.createHook);
-    case "webhookWait":
-      return awaitExternalWait(context, token, bridge?.onExternalWait, primitives.createWebhook ?? primitives.createHook, context.runtime?.webhookWait?.path, context.runtime?.webhookWait?.method);
-    case "approvalWait":
-      return awaitExternalWait(context, token, bridge?.onApprovalRequested, primitives.createHook);
-    case "streamSession":
-      return awaitExternalWait(context, token, bridge?.onStreamSession, primitives.createHook);
-    case "automation":
-      if (!bridge?.executeAutomationStep) {
-        throw new Error("Workflow DevKit bridge requires executeAutomationStep for automation steps.");
-      }
-      return bridge.executeAutomationStep(context);
-    case "human":
-      if (!bridge?.awaitHumanInput) {
-        throw new Error("Workflow DevKit bridge requires awaitHumanInput for human steps without explicit wait behavior.");
-      }
-      return bridge.awaitHumanInput(context);
-    case "decision":
-      return bridge?.executeDecisionStep ? bridge.executeDecisionStep(context) : context.input;
-  }
-}
-async function awaitExternalWait(context, token, notifier, factory, path, method) {
-  if (!token) {
-    throw new Error(`Step "${context.step.id}" requires a Workflow DevKit wait token.`);
-  }
-  const behavior = context.runtime?.behavior;
-  if (behavior !== "approvalWait" && behavior !== "hookWait" && behavior !== "streamSession" && behavior !== "webhookWait") {
-    throw new Error(`Step "${context.step.id}" is not configured with an external wait behavior.`);
-  }
-  const waitContext = {
-    ...context,
-    behavior,
-    token
-  };
-  await notifier?.(waitContext);
-  const hook = factory({ method, path, token });
-  try {
-    return await hook;
-  } finally {
-    await hook.dispose?.();
-  }
-}
-function lookupStep(spec, stepId) {
-  const step = spec.definition.steps.find((candidate) => candidate.id === stepId);
-  if (!step) {
-    throw new Error(`Step "${stepId}" not found in workflow ${spec.meta.key}.v${spec.meta.version}.`);
-  }
-  return step;
-}
-
-// src/index.ts
-import { WorkflowChatTransport } from "@workflow/ai";
-export {
-  withContractSpecWorkflow,
-  sanitizeIdentifier,
-  runWorkflowSpecWithWorkflowDevkit,
-  resolveWorkflowDevkitWaitToken,
-  resolveWorkflowDevkitRunIdentity,
-  resolveWorkflowDevkitNextStepId,
-  resolveWorkflowDevkitEntryStepId,
-  mergeWorkflowDevkitData,
-  inferWorkflowDevkitBehavior,
-  generateWorkflowDevkitArtifacts,
-  defaultWorkflowDevkitAgentToken,
-  createWorkflowDevkitStreamRoute,
-  createWorkflowDevkitStartRoute,
-  createWorkflowDevkitFollowUpRoute,
-  createWorkflowDevkitAgentRuntimeAdapterBundle,
-  compileWorkflowSpecToWorkflowDevkit,
-  WorkflowChatTransport,
-  WORKFLOW_STREAM_TAIL_INDEX_HEADER,
-  WORKFLOW_RUN_ID_HEADER,
-  InMemoryWorkflowDevkitSuspensionStore,
-  InMemoryWorkflowDevkitCheckpointStore
-};
+`}import{withWorkflow as u}from"workflow/next";function c(C){return u(C)}async function a(C){let _=[],H=U(C.spec),A={...C.initialData??{}},O=C.initialData;while(H){let K=p(C.spec,H),L=K.runtime?.workflowDevkit,W={data:A,input:O,runIdentity:C.runIdentity,runtime:L,spec:C.spec,step:K},j=R(K),$=V(C.spec,K,C.runIdentity),J=await r(j,W,$,C.bridge,C.primitives);_.push({behavior:j,input:O,output:J,stepId:K.id,token:$}),A=z(A,O,J);let G=E(C.spec,K,A,O,J);if(!G)return{currentStep:null,data:A,history:_,status:"completed"};H=G,O=J}return{currentStep:null,data:A,history:_,status:"completed"}}async function r(C,_,H,A,O){switch(C){case"sleep":if(!_.runtime?.sleep?.duration)throw Error(`Step "${_.step.id}" is missing sleep.duration.`);return await O.sleep(_.runtime.sleep.duration),{sleptFor:_.runtime.sleep.duration};case"hookWait":return X(_,H,A?.onExternalWait,O.createHook);case"webhookWait":return X(_,H,A?.onExternalWait,O.createWebhook??O.createHook,_.runtime?.webhookWait?.path,_.runtime?.webhookWait?.method);case"approvalWait":return X(_,H,A?.onApprovalRequested,O.createHook);case"streamSession":return X(_,H,A?.onStreamSession,O.createHook);case"automation":if(!A?.executeAutomationStep)throw Error("Workflow DevKit bridge requires executeAutomationStep for automation steps.");return A.executeAutomationStep(_);case"human":if(!A?.awaitHumanInput)throw Error("Workflow DevKit bridge requires awaitHumanInput for human steps without explicit wait behavior.");return A.awaitHumanInput(_);case"decision":return A?.executeDecisionStep?A.executeDecisionStep(_):_.input}}async function X(C,_,H,A,O,K){if(!_)throw Error(`Step "${C.step.id}" requires a Workflow DevKit wait token.`);let L=C.runtime?.behavior;if(L!=="approvalWait"&&L!=="hookWait"&&L!=="streamSession"&&L!=="webhookWait")throw Error(`Step "${C.step.id}" is not configured with an external wait behavior.`);let W={...C,behavior:L,token:_};await H?.(W);let j=A({method:K,path:O,token:_});try{return await j}finally{await j.dispose?.()}}function p(C,_){let H=C.definition.steps.find((A)=>A.id===_);if(!H)throw Error(`Step "${_}" not found in workflow ${C.meta.key}.v${C.meta.version}.`);return H}import{WorkflowChatTransport as jC}from"@workflow/ai";export{c as withContractSpecWorkflow,D as sanitizeIdentifier,a as runWorkflowSpecWithWorkflowDevkit,V as resolveWorkflowDevkitWaitToken,v as resolveWorkflowDevkitRunIdentity,E as resolveWorkflowDevkitNextStepId,U as resolveWorkflowDevkitEntryStepId,z as mergeWorkflowDevkitData,R as inferWorkflowDevkitBehavior,k as generateWorkflowDevkitArtifacts,M as defaultWorkflowDevkitAgentToken,y as createWorkflowDevkitStreamRoute,g as createWorkflowDevkitStartRoute,S as createWorkflowDevkitFollowUpRoute,F as createWorkflowDevkitAgentRuntimeAdapterBundle,q as compileWorkflowSpecToWorkflowDevkit,jC as WorkflowChatTransport,B as WORKFLOW_STREAM_TAIL_INDEX_HEADER,Q as WORKFLOW_RUN_ID_HEADER,Z as InMemoryWorkflowDevkitSuspensionStore,Y as InMemoryWorkflowDevkitCheckpointStore};

package/dist/node/next.js

@@ -1,8 +1 @@
-// src/next.ts
-import { withWorkflow } from "workflow/next";
-function withContractSpecWorkflow(nextConfig) {
-  return withWorkflow(nextConfig);
-}
-export {
-  withContractSpecWorkflow
-};
+import{withWorkflow as t}from"workflow/next";function e(o){return t(o)}export{e as withContractSpecWorkflow};