@ai-sdk/workflow-harness 1.0.44 → 1.0.46

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @ai-sdk/workflow-harness
 
+## 1.0.46
+
+### Patch Changes
+
+- @ai-sdk/harness@1.0.46
+
+## 1.0.45
+
+### Patch Changes
+
+- 214ea9f: feat(workflow-harness): add utility functions for agent-step based workflow step definitions
+  - @ai-sdk/harness@1.0.45
+
 ## 1.0.44
 
 ### Patch Changes

package/README.md

@@ -1,13 +1,14 @@
 # @ai-sdk/workflow-harness
 
 Run an AI SDK `HarnessAgent` (Claude Code, Codex, Pi) as a **durable workflow**
-using the [Workflow DevKit](https://www.npmjs.com/package/workflow).
+using the [Workflow DevKit](https://www.npmjs.com/package/workflow). A turn can
+be divided into time slices or semantic agent steps.
 
-A long agent turn is sliced into short, time-boxed steps so it survives a Fluid
-Compute function recycle (~800s). Between slices the agent is frozen
-non-destructively — the sandbox keeps running and the next slice reattaches to
-the in-flight turn (`attach`) — and a serializable state object is persisted as
-the durable step return value.
+Time slices let a long agent turn survive a Fluid Compute function recycle
+(~800s). Semantic steps let a workflow persist after each agent step, typically
+by configuring the agent with `stopWhen: isStepCount(1)`. At either boundary the
+agent is frozen non-destructively and a serializable state object is persisted
+as the durable step return value.
 
 This package ships plain helpers + a serializable state machine; you own the
 thin `'use workflow'` / `'use step'` wrappers (the Workflow DevKit compiles
@@ -32,21 +33,21 @@ export const agent = new HarnessAgent({
 });
 ```
 
-`run-slice-step.ts`:
+`time-slice-step.ts`:
 
 ```ts
 import {
-  runHarnessAgentSlice,
+  runHarnessAgentTimeSlice,
   type HarnessWorkflowState,
 } from '@ai-sdk/workflow-harness';
 
-export async function runSlice(
+export async function timeSliceStep(
   state: HarnessWorkflowState,
 ): Promise<HarnessWorkflowState> {
   'use step';
 
   const { agent } = await import('./agent');
-  return runHarnessAgentSlice({ agent, state });
+  return runHarnessAgentTimeSlice({ agent, state });
 }
 ```
 
@@ -58,18 +59,78 @@ import {
   finalizeHarnessWorkflow,
   type HarnessWorkflowInput,
 } from '@ai-sdk/workflow-harness';
-import { runSlice } from './run-slice-step';
+import { timeSliceStep } from './time-slice-step';
 
-export async function codingWorkflow(input: {
+export async function timeSliceWorkflow(input: {
   prompt: HarnessWorkflowInput['prompt'];
   sessionId: string;
 }) {
   'use workflow';
 
   let state = createHarnessWorkflowState(input);
-  while (state.status === 'running' || state.status === 'timed_out') {
-    state = await runSlice(state);
-  }
+  do {
+    state = await timeSliceStep(state);
+  } while (state.status === 'ready_for_next_step');
+  return finalizeHarnessWorkflow(state);
+}
+```
+
+For a semantic stepped workflow, configure the agent with
+`stopWhen: isStepCount(1)`, call `runHarnessAgentStep()` from the step module,
+and continue while the status is `ready_for_next_step`:
+
+`stepped-agent.ts`:
+
+```ts
+import { HarnessAgent } from '@ai-sdk/harness/agent';
+import { claudeCode } from '@ai-sdk/harness-claude-code';
+import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
+import { isStepCount } from 'ai';
+
+export const steppedAgent = new HarnessAgent({
+  harness: claudeCode,
+  sandbox: createVercelSandbox({ runtime: 'node24', ports: [4000] }),
+  stopWhen: isStepCount(1),
+});
+```
+
+`stepped-agent-step.ts`:
+
+```ts
+import {
+  runHarnessAgentStep,
+  type HarnessWorkflowState,
+} from '@ai-sdk/workflow-harness';
+
+export async function agentStep(
+  state: HarnessWorkflowState,
+): Promise<HarnessWorkflowState> {
+  'use step';
+
+  const { steppedAgent } = await import('./stepped-agent');
+  return runHarnessAgentStep({ agent: steppedAgent, state });
+}
+```
+
+`stepped-workflow.ts`:
+
+```ts
+import {
+  createHarnessWorkflowState,
+  finalizeHarnessWorkflow,
+  type HarnessWorkflowInput,
+} from '@ai-sdk/workflow-harness';
+import { agentStep } from './stepped-agent-step';
+
+export async function agentWorkflow(
+  input: Pick<HarnessWorkflowInput, 'messages' | 'sessionId'>,
+) {
+  'use workflow';
+
+  let state = createHarnessWorkflowState(input);
+  do {
+    state = await agentStep(state);
+  } while (state.status === 'ready_for_next_step');
   return finalizeHarnessWorkflow(state);
 }
 ```
@@ -78,14 +139,14 @@ export async function codingWorkflow(input: {
 
 ```ts
 import { start } from 'workflow/api';
-import { codingWorkflow } from './workflow';
+import { timeSliceWorkflow } from './workflow';
 
 export async function POST(request: Request) {
   const body = (await request.json()) as {
     prompt: string;
     sessionId: string;
   };
-  const run = await start(codingWorkflow, [body]);
+  const run = await start(timeSliceWorkflow, [body]);
 
   return new Response(run.readable);
 }

package/dist/index.d.ts

@@ -15,17 +15,19 @@ type HarnessWorkflowModelMessage = {
     readonly content: any;
 };
 /**
- * Where a workflow-driven harness run is in its slice loop.
+ * Where a workflow-driven harness run is in its execution loop.
  *
- *  - `running`   — fresh state, no slice has run yet.
- *  - `timed_out` — a slice hit its wall-clock budget; `continueFrom` carries
- *                  the cursor to continue the same turn.
+ *  - `not_started` — fresh state, no workflow step has run yet.
+ *  - `ready_for_next_step` — the turn remains unfinished and `continueFrom`
+ *                  carries the cursor for the next workflow step.
  *  - `awaiting_tool_approval` — the turn emitted one or more tool approval
  *                  requests and `continueFrom` carries the suspended turn.
- *  - `finished`  — the agent turn completed on its own; `finalResult` is set.
- *  - `failed`    — the turn errored; `error` is set.
+ *  - `finished` — the agent turn completed on its own; `finalResult` is set.
+ *  - `failed` — the turn errored; `error` is set.
  */
-type HarnessWorkflowStatus = 'running' | 'timed_out' | 'awaiting_tool_approval' | 'finished' | 'failed';
+type HarnessWorkflowStatus = 'not_started' | 'ready_for_next_step' | 'awaiting_tool_approval' | 'finished' | 'failed'
+/** @deprecated Use `ready_for_next_step` instead. */
+ | 'timed_out';
 interface HarnessWorkflowUsageSummary {
     readonly inputTokens?: number;
     readonly outputTokens?: number;
@@ -45,7 +47,7 @@ interface HarnessWorkflowStreamContext {
     readonly pendingToolInputs?: Record<string, HarnessWorkflowSerializedChunk>;
 }
 /**
- * Serializable state machine threaded between workflow slices. A `'use step'`
+ * Serializable state machine threaded between workflow steps. A `'use step'`
  * returns the next value of this object, and the Workflow DevKit persists that
  * return value — so this is the entire durable state of a harness run. Every
  * field must be JSON-serializable.
@@ -68,13 +70,13 @@ interface HarnessWorkflowState {
      * The new user turn for this run — a plain string or a single
      * `UserModelMessage` (the harness's own {@link HarnessV1Prompt}), so
      * structured content survives instead of being flattened to text. Sent once,
-     * on the slice that starts the turn.
+     * on the execution that starts the turn.
      */
     readonly prompt: HarnessV1Prompt;
     /**
      * Full AI SDK model messages for continuing a suspended approval turn. When
-     * present, the next slice sends these to `HarnessAgent.stream()` so approval
-     * responses can resume the suspended turn.
+     * present, the next execution sends these to `HarnessAgent.stream()` so
+     * approval responses can resume the suspended turn.
      */
     readonly messages?: HarnessWorkflowModelMessage[];
     readonly status: HarnessWorkflowStatus;
@@ -85,8 +87,8 @@ interface HarnessWorkflowState {
     readonly resumeFrom?: HarnessV1ResumeSessionState;
     /**
      * Continuation coordinates for this run's current suspended turn. When
-     * present, the next slice must call `continueTurn` rather than sending
-     * `prompt` again.
+     * present, the next execution continues the turn rather than sending `prompt`
+     * again.
      */
     readonly continueFrom?: HarnessV1ContinueTurnState;
     readonly streamContext?: HarnessWorkflowStreamContext;
@@ -125,7 +127,7 @@ interface HarnessWorkflowChunk {
     readonly [key: string]: unknown;
 }
 /**
- * The subset of a harness `stream()` / `continueStream()` result the slice loop uses.
+ * The subset of a harness `stream()` / `continueStream()` result the runner uses.
  * `StreamTextResult` satisfies it structurally.
  */
 interface HarnessWorkflowStreamResult {
@@ -134,7 +136,7 @@ interface HarnessWorkflowStreamResult {
     readonly totalUsage: PromiseLike<unknown>;
 }
 /**
- * The subset of `HarnessAgent` the slice loop drives. Declared structurally so
+ * The subset of `HarnessAgent` the runner drives. Declared structurally so
  * the engine is decoupled from the concrete agent generics and easy to mock.
  */
 interface HarnessWorkflowAgent {
@@ -161,11 +163,10 @@ interface HarnessWorkflowAgent {
         session: HarnessAgentSession;
     }): Promise<HarnessWorkflowStreamResult>;
 }
-interface RunHarnessAgentSliceOptions {
+interface RunHarnessAgentOptions {
     readonly agent: HarnessWorkflowAgent;
     readonly state: HarnessWorkflowState;
-    /** Wall-clock budget for this slice. Defaults to {@link DEFAULT_SLICE_TIMEOUT_SECONDS}. */
-    readonly sliceTimeoutSeconds?: number;
+    readonly timeSliceSeconds?: number;
     /**
      * When the turn finishes, whether to destroy the sandbox. Defaults to `false`:
      * the session is parked or stopped and a fresh resume state is returned in
@@ -181,20 +182,42 @@ interface RunHarnessAgentSliceOptions {
      */
     readonly writable?: WritableStream<HarnessWorkflowChunk>;
 }
+
+type RunHarnessAgentStepOptions = Omit<RunHarnessAgentOptions, 'timeSliceSeconds'>;
 /**
- * Run one durable slice of a harness agent turn.
+ * Run a harness agent until its next semantic step boundary.
  *
- * Intended to be the body of a consumer's `'use step'`: it resumes (or starts)
- * the session, streams the turn's chunks to the workflow output, and races the
- * turn against a wall-clock budget. If the budget fires first it freezes the
- * turn with `session.suspendTurn()` (the sandbox keeps running) and returns a
- * `timed_out` state carrying continuation state for the next slice; if the
- * turn finishes first it returns a `finished` state with the result.
+ * Configure the agent with a `stopWhen` condition such as `isStepCount(1)`.
+ * When that condition completes a result while the underlying turn remains
+ * unfinished, the returned state has status `ready_for_next_step` and carries
+ * the continuation state for the next workflow step.
+ */
+declare function runHarnessAgentStep(options: RunHarnessAgentStepOptions): Promise<HarnessWorkflowState>;
+
+interface RunHarnessAgentTimeSliceOptions extends Omit<RunHarnessAgentOptions, 'timeSliceSeconds'> {
+    /**
+     * Wall-clock budget for one time slice. Defaults to 750 seconds.
+     */
+    readonly timeSliceSeconds?: number;
+}
+/**
+ * Run one time-boxed slice of a durable harness agent turn.
  *
- * The returned {@link HarnessWorkflowState} is serializable and is meant to be
- * the step's return value — the Workflow DevKit persists it as the durable
- * checkpoint between slices.
+ * When the time slice completes before the turn, the returned state has status
+ * `ready_for_next_step` and carries the continuation state for the next slice.
+ */
+declare function runHarnessAgentTimeSlice(options: RunHarnessAgentTimeSliceOptions): Promise<HarnessWorkflowState>;
+
+interface RunHarnessAgentSliceOptions extends Omit<RunHarnessAgentTimeSliceOptions, 'timeSliceSeconds'> {
+    readonly timeSliceSeconds?: number;
+    /**
+     * @deprecated Use `timeSliceSeconds` instead.
+     */
+    readonly sliceTimeoutSeconds?: number;
+}
+/**
+ * @deprecated Use {@link runHarnessAgentTimeSlice} instead.
  */
 declare function runHarnessAgentSlice(options: RunHarnessAgentSliceOptions): Promise<HarnessWorkflowState>;
 
-export { type HarnessWorkflowAgent, type HarnessWorkflowChunk, type HarnessWorkflowFinalResult, type HarnessWorkflowInput, type HarnessWorkflowModelMessage, type HarnessWorkflowState, type HarnessWorkflowStatus, type HarnessWorkflowStreamResult, type HarnessWorkflowUsageSummary, type RunHarnessAgentSliceOptions, createHarnessWorkflowState, finalizeHarnessWorkflow, runHarnessAgentSlice };
+export { type HarnessWorkflowAgent, type HarnessWorkflowChunk, type HarnessWorkflowFinalResult, type HarnessWorkflowInput, type HarnessWorkflowModelMessage, type HarnessWorkflowState, type HarnessWorkflowStatus, type HarnessWorkflowStreamResult, type HarnessWorkflowUsageSummary, type RunHarnessAgentSliceOptions, type RunHarnessAgentStepOptions, type RunHarnessAgentTimeSliceOptions, createHarnessWorkflowState, finalizeHarnessWorkflow, runHarnessAgentSlice, runHarnessAgentStep, runHarnessAgentTimeSlice };

package/dist/index.js

@@ -4,7 +4,7 @@ function createHarnessWorkflowState(input) {
     sessionId: input.sessionId,
     prompt: input.prompt ?? "",
     ...input.messages != null ? { messages: input.messages } : {},
-    status: "running",
+    status: "not_started",
     ...input.resumeFrom != null ? { resumeFrom: input.resumeFrom } : {},
     ...input.continueFrom != null ? { continueFrom: input.continueFrom } : {}
   };
@@ -19,11 +19,9 @@ function finalizeHarnessWorkflow(state) {
   return { sessionId: state.sessionId, finishReason: "unknown" };
 }
 
-// src/run-harness-agent-slice.ts
-var DEFAULT_SLICE_TIMEOUT_SECONDS = 750;
-async function runHarnessAgentSlice(options) {
+// src/run-harness-agent.ts
+async function runHarnessAgent(options) {
   const { agent, state } = options;
-  const sliceTimeoutSeconds = options.sliceTimeoutSeconds ?? DEFAULT_SLICE_TIMEOUT_SECONDS;
   const destroyOnFinish = options.destroyOnFinish ?? false;
   const session = state.continueFrom != null ? await agent.createSession({
     sessionId: state.sessionId,
@@ -55,12 +53,12 @@ async function runHarnessAgentSlice(options) {
   const writable = options.writable ?? await resolveWorkflowWritable();
   const writer = writable.getWriter();
   const streamContext = createMutableStreamContext(state.streamContext);
-  const slicePartState = createSlicePartState();
+  const executionPartState = createExecutionPartState();
   let suspendPromise;
-  const timer = setTimeout(() => {
+  const timer = options.timeSliceSeconds == null ? void 0 : setTimeout(() => {
     suspendPromise = session.suspendTurn();
-  }, sliceTimeoutSeconds * 1e3);
-  timer.unref?.();
+  }, options.timeSliceSeconds * 1e3);
+  timer?.unref?.();
   let sawError = false;
   let writerClosed = false;
   try {
@@ -83,11 +81,11 @@ async function runHarnessAgentSlice(options) {
           chunk: value,
           writer,
           streamContext,
-          slicePartState
+          executionPartState
         });
       }
     } finally {
-      clearTimeout(timer);
+      if (timer != null) clearTimeout(timer);
       reader.releaseLock();
     }
     if (sawError) {
@@ -105,15 +103,15 @@ async function runHarnessAgentSlice(options) {
     }
     if (suspendPromise != null) {
       const continueFrom = await suspendPromise;
-      await closeOpenSliceParts({
+      await closeOpenExecutionParts({
         writer,
         streamContext,
-        slicePartState
+        executionPartState
       });
       return {
         sessionId: state.sessionId,
         prompt: state.prompt,
-        status: "timed_out",
+        status: "ready_for_next_step",
         continueFrom,
         ...serializeStreamContextField(streamContext)
       };
@@ -123,16 +121,39 @@ async function runHarnessAgentSlice(options) {
       Promise.resolve(result.totalUsage).catch(() => void 0)
     ]);
     const normalizedFinishReason = toFinishReasonString(finishReason);
-    if (normalizedFinishReason === "tool-calls") {
+    if (session.hasUnfinishedTurn()) {
       const continueFrom = await session.suspendTurn();
-      await writer.write({ type: "finish", finishReason: "tool-calls" });
+      if (!hasPendingHostInput(continueFrom)) {
+        await closeOpenExecutionParts({
+          writer,
+          streamContext,
+          executionPartState
+        });
+        return {
+          sessionId: state.sessionId,
+          prompt: state.prompt,
+          status: "ready_for_next_step",
+          continueFrom,
+          ...serializeStreamContextField(streamContext)
+        };
+      }
+      await writer.write({
+        type: "finish",
+        finishReason: normalizedFinishReason
+      });
       await writer.close();
       writerClosed = true;
       return {
         sessionId: state.sessionId,
         prompt: state.prompt,
         status: "awaiting_tool_approval",
-        continueFrom
+        continueFrom,
+        resumeFrom: toResumeState({ continueFrom }),
+        finalResult: {
+          sessionId: state.sessionId,
+          finishReason: normalizedFinishReason,
+          usage: toUsageSummary(usage)
+        }
       };
     }
     await writer.write({ type: "finish" });
@@ -167,7 +188,7 @@ function createMutableStreamContext(context) {
     pendingToolInputs: { ...context?.pendingToolInputs ?? {} }
   };
 }
-function createSlicePartState() {
+function createExecutionPartState() {
   return {
     openedTextParts: /* @__PURE__ */ new Set(),
     openedReasoningParts: /* @__PURE__ */ new Set(),
@@ -180,74 +201,74 @@ async function writeWorkflowChunk(options) {
   recordWorkflowChunk(options);
 }
 async function writeRequiredPrelude(options) {
-  const { chunk, writer, streamContext, slicePartState } = options;
+  const { chunk, writer, streamContext, executionPartState } = options;
   const id = stringProperty({ chunk, key: "id" });
-  if ((chunk.type === "text-delta" || chunk.type === "text-end") && id != null && streamContext.activeTextParts[id] != null && !slicePartState.openedTextParts.has(id)) {
+  if ((chunk.type === "text-delta" || chunk.type === "text-end") && id != null && streamContext.activeTextParts[id] != null && !executionPartState.openedTextParts.has(id)) {
     await writer.write(streamContext.activeTextParts[id]);
-    slicePartState.openedTextParts.add(id);
+    executionPartState.openedTextParts.add(id);
   }
-  if ((chunk.type === "reasoning-delta" || chunk.type === "reasoning-end") && id != null && streamContext.activeReasoningParts[id] != null && !slicePartState.openedReasoningParts.has(id)) {
+  if ((chunk.type === "reasoning-delta" || chunk.type === "reasoning-end") && id != null && streamContext.activeReasoningParts[id] != null && !executionPartState.openedReasoningParts.has(id)) {
     await writer.write(streamContext.activeReasoningParts[id]);
-    slicePartState.openedReasoningParts.add(id);
+    executionPartState.openedReasoningParts.add(id);
   }
   const toolCallId = stringProperty({ chunk, key: "toolCallId" });
-  if (toolCallId != null && needsToolInputPrelude(chunk) && streamContext.pendingToolInputs[toolCallId] != null && !slicePartState.writtenToolInputs.has(toolCallId)) {
+  if (toolCallId != null && needsToolInputPrelude(chunk) && streamContext.pendingToolInputs[toolCallId] != null && !executionPartState.writtenToolInputs.has(toolCallId)) {
     await writer.write(streamContext.pendingToolInputs[toolCallId]);
-    slicePartState.writtenToolInputs.add(toolCallId);
+    executionPartState.writtenToolInputs.add(toolCallId);
   }
 }
 function recordWorkflowChunk(options) {
-  const { chunk, streamContext, slicePartState } = options;
+  const { chunk, streamContext, executionPartState } = options;
   const id = stringProperty({ chunk, key: "id" });
   const toolCallId = stringProperty({ chunk, key: "toolCallId" });
   if (chunk.type === "text-start" && id != null) {
     streamContext.activeTextParts[id] = cloneChunk(chunk);
-    slicePartState.openedTextParts.add(id);
+    executionPartState.openedTextParts.add(id);
     return;
   }
   if (chunk.type === "text-end" && id != null) {
     delete streamContext.activeTextParts[id];
-    slicePartState.openedTextParts.delete(id);
+    executionPartState.openedTextParts.delete(id);
     return;
   }
   if (chunk.type === "reasoning-start" && id != null) {
     streamContext.activeReasoningParts[id] = cloneChunk(chunk);
-    slicePartState.openedReasoningParts.add(id);
+    executionPartState.openedReasoningParts.add(id);
     return;
   }
   if (chunk.type === "reasoning-end" && id != null) {
     delete streamContext.activeReasoningParts[id];
-    slicePartState.openedReasoningParts.delete(id);
+    executionPartState.openedReasoningParts.delete(id);
     return;
   }
   if (chunk.type === "tool-input-available" && toolCallId != null) {
     streamContext.pendingToolInputs[toolCallId] = cloneChunk(chunk);
-    slicePartState.writtenToolInputs.add(toolCallId);
+    executionPartState.writtenToolInputs.add(toolCallId);
     return;
   }
   if (chunk.type === "tool-input-error" && toolCallId != null) {
     delete streamContext.pendingToolInputs[toolCallId];
-    slicePartState.writtenToolInputs.add(toolCallId);
+    executionPartState.writtenToolInputs.add(toolCallId);
     return;
   }
   if ((chunk.type === "tool-output-error" || chunk.type === "tool-output-denied" || chunk.type === "tool-output-available" && chunk.preliminary !== true) && toolCallId != null) {
     delete streamContext.pendingToolInputs[toolCallId];
   }
 }
-async function closeOpenSliceParts(options) {
-  const { writer, streamContext, slicePartState } = options;
-  for (const id of slicePartState.openedTextParts) {
+async function closeOpenExecutionParts(options) {
+  const { writer, streamContext, executionPartState } = options;
+  for (const id of executionPartState.openedTextParts) {
     if (streamContext.activeTextParts[id] != null) {
       await writer.write({ type: "text-end", id });
     }
   }
-  slicePartState.openedTextParts.clear();
-  for (const id of slicePartState.openedReasoningParts) {
+  executionPartState.openedTextParts.clear();
+  for (const id of executionPartState.openedReasoningParts) {
     if (streamContext.activeReasoningParts[id] != null) {
       await writer.write({ type: "reasoning-end", id });
     }
   }
-  slicePartState.openedReasoningParts.clear();
+  executionPartState.openedReasoningParts.clear();
 }
 function serializeStreamContextField(context) {
   const streamContext = {
@@ -260,6 +281,19 @@ function serializeStreamContextField(context) {
 function needsToolInputPrelude(chunk) {
   return chunk.type === "tool-approval-request" || chunk.type === "tool-output-available" || chunk.type === "tool-output-error" || chunk.type === "tool-output-denied";
 }
+function hasPendingHostInput(state) {
+  return (state.pendingToolApprovals?.length ?? 0) > 0 || (state.pendingToolResults?.length ?? 0) > 0;
+}
+function toResumeState(options) {
+  const { continueFrom } = options;
+  return {
+    type: "resume-session",
+    harnessId: continueFrom.harnessId,
+    specificationVersion: continueFrom.specificationVersion,
+    data: continueFrom.data,
+    continueFrom
+  };
+}
 function stringProperty(options) {
   const value = options.chunk[options.key];
   return typeof value === "string" ? value : void 0;
@@ -304,9 +338,35 @@ function toUsageSummary(usage) {
     ...outputTokens != null ? { outputTokens } : {}
   };
 }
+
+// src/run-harness-agent-step.ts
+async function runHarnessAgentStep(options) {
+  return runHarnessAgent(options);
+}
+
+// src/run-harness-agent-time-slice.ts
+var DEFAULT_TIME_SLICE_SECONDS = 750;
+async function runHarnessAgentTimeSlice(options) {
+  return runHarnessAgent({
+    ...options,
+    timeSliceSeconds: options.timeSliceSeconds ?? DEFAULT_TIME_SLICE_SECONDS
+  });
+}
+
+// src/run-harness-agent-slice.ts
+async function runHarnessAgentSlice(options) {
+  const { sliceTimeoutSeconds, timeSliceSeconds, ...timeSliceOptions } = options;
+  const state = await runHarnessAgentTimeSlice({
+    ...timeSliceOptions,
+    timeSliceSeconds: timeSliceSeconds ?? sliceTimeoutSeconds
+  });
+  return state.status === "ready_for_next_step" ? { ...state, status: "timed_out" } : state;
+}
 export {
   createHarnessWorkflowState,
   finalizeHarnessWorkflow,
-  runHarnessAgentSlice
+  runHarnessAgentSlice,
+  runHarnessAgentStep,
+  runHarnessAgentTimeSlice
 };
 //# sourceMappingURL=index.js.map