@ai-sdk/harness 1.0.0-canary.6 → 1.0.0-canary.8

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @ai-sdk/harness
 
+## 1.0.0-canary.8
+
+### Patch Changes
+
+- aae0138: fix(harness): make listening for sandbox bridge readiness compatible with Bun
+
+## 1.0.0-canary.7
+
+### Patch Changes
+
+- 3d87086: fix(harness): guard against invalid resuming a session vs continuing a turn
+- 1ea15a3: fix(harness): fix various bugs with harness skills not being correctly processed by the harness adapters
+- Updated dependencies [aeda373]
+- Updated dependencies [25a64f8]
+- Updated dependencies [375fdd7]
+- Updated dependencies [f18b08f]
+- Updated dependencies [b4507d5]
+  - @ai-sdk/provider-utils@5.0.0-canary.48
+  - ai@7.0.0-canary.172
+
 ## 1.0.0-canary.6
 
 ### Patch Changes

package/dist/agent/index.d.ts

@@ -381,12 +381,6 @@ type HarnessV1LifecycleStateBase = {
      * responsible for any necessary encoding.
      */
     readonly data: JSONValue;
-    /**
-     * Framework-owned pending approval records. These are intentionally outside
-     * adapter-defined `data` so callers can persist the entire lifecycle payload
-     * without the harness framework owning storage.
-     */
-    readonly pendingToolApprovals?: readonly HarnessV1PendingToolApproval[];
 };
 /**
  * Opaque payload returned by between-turn session lifecycle methods and
@@ -395,6 +389,11 @@ type HarnessV1LifecycleStateBase = {
  */
 type HarnessV1ResumeSessionState = HarnessV1LifecycleStateBase & {
     readonly type: 'resume-session';
+    /**
+     * Optional unfinished-turn state. When present, the session must be resumed
+     * before the turn is continued.
+     */
+    readonly continueFrom?: HarnessV1ContinueTurnState;
 };
 /**
  * Opaque payload returned by `doSuspendTurn` and accepted by a future
@@ -403,28 +402,45 @@ type HarnessV1ResumeSessionState = HarnessV1LifecycleStateBase & {
  */
 type HarnessV1ContinueTurnState = HarnessV1LifecycleStateBase & {
     readonly type: 'continue-turn';
+    /**
+     * Framework-owned pending approval records. These are intentionally outside
+     * adapter-defined `data` so callers can persist the entire lifecycle payload
+     * without the harness framework owning storage.
+     */
+    readonly pendingToolApprovals?: readonly HarnessV1PendingToolApproval[];
 };
 type HarnessV1LifecycleState = HarnessV1ResumeSessionState | HarnessV1ContinueTurnState;
 
 /**
  * A self-contained instruction bundle the underlying runtime can load into
- * its context. Adapters decide how to surface skills to the runtime — the
- * `claude` CLI auto-discovers skills materialised as Markdown files in
- * `.claude/skills`, while the `codex` CLI has no skill mechanism and the
- * adapter inlines them into every user message.
+ * its context. Adapters decide how to surface skills to the runtime.
  */
 type HarnessV1Skill = {
     /** Stable identifier for the skill (kebab-case slug). */
     readonly name: string;
     /**
-     * Short, model-facing description. For runtimes that auto-select skills
-     * (Claude Code), this is what the runtime sees to decide whether the
-     * skill is relevant; for runtimes that load every skill on every turn
-     * (Codex), it appears alongside the content.
+     * Short, model-facing description. This is what the runtime sees to
+     * decide whether the skill is relevant.
      */
     readonly description: string;
     /** Full skill content the model loads when the skill is active. */
     readonly content: string;
+    /**
+     * Additional files that belong to this skill. Adapters with native skill
+     * directories materialize these next to `SKILL.md`; adapters without native
+     * skill files include them with the skill content.
+     */
+    readonly files?: ReadonlyArray<HarnessV1SkillFile>;
+};
+type HarnessV1SkillFile = {
+    /**
+     * Skill-relative POSIX path, for example `reference.md` or
+     * `references/codes.md`. Absolute paths and `..` segments are rejected by
+     * adapters before writing.
+     */
+    readonly path: string;
+    /** UTF-8 text content for the file. */
+    readonly content: string;
 };
 
 /**
@@ -585,21 +601,19 @@ type HarnessV1StartOptions = {
     readonly sessionId: string;
     /**
      * Skills made available to the underlying runtime for the lifetime of
-     * the session. Adapters decide how to surface them — the `claude` CLI
-     * picks them up from `.claude/skills/*.md`, while the `codex` adapter
-     * inlines them into every user message.
+     * the session. Adapters decide how to surface them.
      */
     readonly skills?: ReadonlyArray<HarnessV1Skill>;
     /**
-     * Optional resume payload returned by a prior between-turn session lifecycle
-     * method. When provided, the adapter should resume the existing session before
-     * accepting a new prompt.
+     * Optional resume payload returned by a prior session lifecycle method. When
+     * provided, the adapter should resume the existing session before accepting a
+     * new prompt or continuing a nested unfinished turn.
      */
     readonly resumeFrom?: HarnessV1ResumeSessionState;
     /**
-     * Optional continuation payload returned by `doSuspendTurn`. When provided,
-     * the adapter should resume the existing session in a shape ready for
-     * `doContinueTurn` rather than for a fresh prompt.
+     * Optional continuation payload returned by `doSuspendTurn`, or nested in
+     * `resumeFrom`. When provided, the adapter should resume the existing session
+     * in a shape ready for `doContinueTurn` rather than for a fresh prompt.
      */
     readonly continueFrom?: HarnessV1ContinueTurnState;
     /**
@@ -1151,6 +1165,7 @@ type HarnessAgentTurnResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Conte
     result: StreamTextResult<TOOLS, RUNTIME_CONTEXT, never>;
     done: Promise<void>;
 };
+type HarnessAgentTurnState = 'idle' | 'running' | 'awaiting-approval' | 'suspended';
 /**
  * Live harness session held by the caller.
  *
@@ -1180,7 +1195,10 @@ declare class HarnessAgentSession {
     private leasedBridgePort;
     private readonly toolApproval;
     private readonly pendingToolApprovals;
-    private stopped;
+    private sessionState;
+    private turnState;
+    private turnSequence;
+    private activeTurnSequence;
     /**
      * Whether this session was created from `resumeFrom` or `continueFrom`.
      * Captured at construction so it survives lifecycle cleanup.
@@ -1196,6 +1214,7 @@ declare class HarnessAgentSession {
         sessionWorkDir: string;
         toolApproval: HarnessAgentToolApprovalConfiguration | undefined;
         pendingToolApprovals?: readonly HarnessAgentPendingToolApproval[];
+        turnState?: HarnessAgentTurnState;
     });
     promptTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context>(options: {
         prompt: HarnessAgentPrompt;
@@ -1247,11 +1266,11 @@ declare class HarnessAgentSession {
     /**
      * Gracefully freeze the active turn at the slice boundary and return the
      * continuation payload, **leaving the sandbox/runtime running** so the next
-     * process can continue. Resolves once the in-flight `stream()`/`continueTurn()`
-     * has cleanly wound down at a precise cursor (see
+     * process can continue. Resolves once the in-flight `stream()` /
+     * `continueStream()` has cleanly wound down at a precise cursor (see
      * `doSuspendTurn`).
      *
-     * After this call the session is marked stopped. This in-process handle no
+     * After this call the session is detached. This in-process handle no
      * longer drives turns; a future slice creates a fresh session from the
      * returned state. The sandbox is **not** stopped and no port lease is
      * released, because bridge-backed adapters may still have a live bridge on
@@ -1259,7 +1278,15 @@ declare class HarnessAgentSession {
      */
     suspendTurn(): Promise<HarnessAgentContinueTurnState>;
     private getPendingToolApprovals;
-    private withPendingToolApprovals;
+    private addPendingToolApprovals;
+    private suspendCurrentTurn;
+    private toResumeStateWithContinuation;
+    private requirePromptableTurn;
+    private requireContinuableTurn;
+    private markAwaitingApprovalIfActive;
+    private startTrackedTurn;
+    private trackTurnCompletion;
+    private finishTrackedTurn;
     private endLocalHandle;
     private releasePortLease;
     private requireReusableSession;
@@ -1304,7 +1331,8 @@ interface HarnessAgentCallExtensions {
  *    `session.stop()`. The framework validates `resumeFrom` against the
  *    harness's `lifecycleStateSchema` before handing it to the adapter.
  *    `createSession({ sessionId, continueFrom })` resumes from state returned
- *    by `session.suspendTurn()` before `continueTurn()`.
+ *    by `session.suspendTurn()` before `continueStream()` /
+ *    `continueGenerate()`.
  *  - **Host tool execution.** User tools passed in `settings.tools` are
  *    executed on the host whenever the underlying runtime calls them;
  *    the result is fed back to the harness via `submitToolResult`.
@@ -1365,6 +1393,16 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
     }): Promise<HarnessAgentSession>;
     generate(options: AgentCallParameters<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, never>>;
     stream(options: AgentStreamParameters<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, never>>;
+    /**
+     * Continue the in-flight turn **without a new prompt**, draining it like
+     * {@link generate}. Used after `createSession({ continueFrom })` to finish
+     * consuming a turn that crossed a process boundary.
+     */
+    continueGenerate(options: {
+        session: HarnessAgentSession;
+        toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
+        abortSignal?: AbortSignal;
+    }): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, never>>;
     /**
      * Continue the in-flight turn **without a new prompt**, streaming its events
      * like {@link stream}. Used to keep consuming a turn that is still running
@@ -1373,7 +1411,7 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
      * `doContinueTurn`; what it can guarantee (lossless attach vs. lossy rerun)
      * follows from how the adapter resumed the session.
      */
-    continueTurn(options: {
+    continueStream(options: {
         session: HarnessAgentSession;
         toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
         abortSignal?: AbortSignal;