@contractspec/integration.workflow-devkit 0.1.1

package/dist/index.js

@@ -0,0 +1,480 @@
+// @bun
+// 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;
+}
+
+// src/helpers.ts
+import { evaluateExpression } from "@contractspec/lib.contracts-spec/workflow";
+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},
+  createBridge() {
+    return {
+      executeAutomationStep: async () => {
+        throw new Error("Provide executeAutomationStep in your generic host bridge.");
+      },
+    };
+  },
+};
+`;
+}
+function createStartRouteTemplate(workflowFunctionName) {
+  return `import { createWorkflowDevkitStartRoute } from "@contractspec/integration.workflow-devkit";
+import { ${workflowFunctionName} } from "./workflow";
+
+export const POST = createWorkflowDevkitStartRoute({
+  workflow: ${workflowFunctionName},
+  async buildArgs(body) {
+    return [body];
+  },
+});
+`;
+}
+function createFollowUpRouteTemplate(workflowFunctionName) {
+  return `import { createWorkflowDevkitFollowUpRoute } from "@contractspec/integration.workflow-devkit";
+
+export const POST = createWorkflowDevkitFollowUpRoute({
+  resolveToken({ runId }) {
+    return \`${workflowFunctionName}:\${runId}\`;
+  },
+});
+`;
+}
+function createStreamRouteTemplate() {
+  return `import { createWorkflowDevkitStreamRoute } from "@contractspec/integration.workflow-devkit";
+
+export const GET = createWorkflowDevkitStreamRoute();
+`;
+}
+function createWorkflowModuleTemplate(exportName, specImportPath, workflowFunctionName) {
+  return `import { createHook, createWebhook, sleep } from "workflow";
+import { runWorkflowSpecWithWorkflowDevkit } from "@contractspec/integration.workflow-devkit";
+import { ${exportName} } from "${specImportPath}";
+
+export async function ${workflowFunctionName}(input = {}, bridge = {}) {
+  "use workflow";
+
+  return runWorkflowSpecWithWorkflowDevkit({
+    spec: ${exportName},
+    initialData: input,
+    bridge,
+    primitives: {
+      sleep,
+      createHook,
+      createWebhook,
+    },
+  });
+}
+`;
+}
+
+// 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
+};

package/dist/next.d.ts

@@ -0,0 +1 @@
+export declare function withContractSpecWorkflow<TNextConfig>(nextConfig: TNextConfig): TNextConfig;

package/dist/next.js

@@ -0,0 +1,9 @@
+// @bun
+// src/next.ts
+import { withWorkflow } from "workflow/next";
+function withContractSpecWorkflow(nextConfig) {
+  return withWorkflow(nextConfig);
+}
+export {
+  withContractSpecWorkflow
+};

package/dist/node/agent-adapter.js

@@ -0,0 +1,79 @@
+// 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}`;
+}
+export {
+  defaultWorkflowDevkitAgentToken,
+  createWorkflowDevkitAgentRuntimeAdapterBundle,
+  InMemoryWorkflowDevkitSuspensionStore,
+  InMemoryWorkflowDevkitCheckpointStore
+};

package/dist/node/chat-routes.js

@@ -0,0 +1,100 @@
+// 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;
+}
+export {
+  createWorkflowDevkitStreamRoute,
+  createWorkflowDevkitStartRoute,
+  createWorkflowDevkitFollowUpRoute,
+  WORKFLOW_STREAM_TAIL_INDEX_HEADER,
+  WORKFLOW_RUN_ID_HEADER
+};