@ai-sdk/harness 0.0.0 → 1.0.0-beta.14

package/src/agent/internal/strip-work-dir.ts

@@ -0,0 +1,68 @@
+import type { HarnessV1StreamPart } from '../../v1';
+
+/**
+ * Remove the session working-directory prefix from path-bearing fields of a
+ * stream event, returning a new event for display to consumers.
+ *
+ * Harness adapters run the agent in a per-session working directory that is a
+ * subdirectory of the sandbox root, and the agent's tools use absolute paths so
+ * they resolve against the root regardless of where the runtime process
+ * operates. The absolute paths are correct but noisy in a UI, so this strips
+ * the prefix for the consumer-facing projection only.
+ *
+ * Blanket prefix replacement (rather than rewriting known path fields) is used
+ * deliberately: `tool-result` results are free-form text — command stdout, grep
+ * output — where paths can appear anywhere and field-aware rewriting is
+ * impossible. The prefix is long and contains the session id, so it is unique
+ * enough that replacing every occurrence is safe.
+ */
+export function stripWorkDir(
+  part: HarnessV1StreamPart,
+  sessionWorkDir: string,
+): HarnessV1StreamPart {
+  if (sessionWorkDir.length === 0) return part;
+
+  switch (part.type) {
+    case 'tool-call':
+      return { ...part, input: stripString(part.input, sessionWorkDir) };
+    case 'tool-result':
+      return {
+        ...part,
+        result: stripDeep(part.result, sessionWorkDir) as Extract<
+          HarnessV1StreamPart,
+          { type: 'tool-result' }
+        >['result'],
+      };
+    case 'file-change':
+      return { ...part, path: stripString(part.path, sessionWorkDir) };
+    default:
+      return part;
+  }
+}
+
+/**
+ * Replace occurrences of the working directory in a string. A reference to the
+ * directory followed by a separator becomes workspace-relative
+ * (`/work/dir/src/a.ts` → `src/a.ts`); a bare reference to the directory itself
+ * becomes `.`.
+ */
+function stripString(value: string, workDir: string): string {
+  return value.split(`${workDir}/`).join('').split(workDir).join('.');
+}
+
+/**
+ * Recursively strip the working directory from every string nested in an
+ * arbitrary JSON-like value. Non-string leaves are returned unchanged.
+ */
+function stripDeep(value: unknown, workDir: string): unknown {
+  if (typeof value === 'string') return stripString(value, workDir);
+  if (Array.isArray(value)) return value.map(item => stripDeep(item, workDir));
+  if (value !== null && typeof value === 'object') {
+    const out: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(value)) {
+      out[key] = stripDeep(val, workDir);
+    }
+    return out;
+  }
+  return value;
+}

package/src/agent/internal/to-harness-stream.ts

@@ -0,0 +1,75 @@
+import type { HarnessV1PromptControl } from '../../v1/harness-v1-prompt-control';
+import type { HarnessV1StreamPart } from '../../v1/harness-v1-stream-part';
+
+/**
+ * Bridge an adapter's emit-based event surface into a pull-based
+ * `ReadableStream<HarnessV1StreamPart>`.
+ *
+ * Adapters implement `doPromptTurn` / `doContinueTurn` against an `emit` callback
+ * because that is the natural shape when wrapping an SDK that itself produces
+ * events. Consumers (notably `HarnessAgent`) prefer a stream because that is
+ * the idiomatic AI SDK shape. This helper converts the former into the latter
+ * and is agnostic to which turn entry point produced the control surface — the
+ * caller supplies an `invoke` thunk that wires `emit` into either method.
+ *
+ * Lifetime:
+ *   1. Calls `invoke(emit)` immediately (which runs `doPromptTurn`/`doContinueTurn`).
+ *   2. Every `emit(part)` becomes a stream chunk.
+ *   3. When `control.done` resolves, the stream closes — this includes a
+ *      graceful `doSuspendTurn`, which resolves `done` cleanly after draining.
+ *   4. When `control.done` rejects, an `{ type: 'error', error }` part is
+ *      enqueued and the stream is then closed normally. The rejection is
+ *      surfaced to consumers as a discriminated-union event rather than as
+ *      a stream error so iteration code does not need a separate try/catch
+ *      around the consumer loop.
+ *   5. The supplied `abortSignal` (if any) aborts the underlying turn and
+ *      closes the stream.
+ *
+ * The returned `control` is the same object the adapter produced and is
+ * intended for use by the consumer to submit tool results / approvals /
+ * user messages back into the in-flight turn.
+ */
+export async function toHarnessStream(options: {
+  invoke: (
+    emit: (event: HarnessV1StreamPart) => void,
+  ) => PromiseLike<HarnessV1PromptControl>;
+}): Promise<{
+  stream: ReadableStream<HarnessV1StreamPart>;
+  control: HarnessV1PromptControl;
+}> {
+  let controller!: ReadableStreamDefaultController<HarnessV1StreamPart>;
+  let closed = false;
+
+  const stream = new ReadableStream<HarnessV1StreamPart>({
+    start(c) {
+      controller = c;
+    },
+  });
+
+  const safeEnqueue = (part: HarnessV1StreamPart) => {
+    if (closed) return;
+    controller.enqueue(part);
+  };
+
+  const safeClose = () => {
+    if (closed) return;
+    closed = true;
+    controller.close();
+  };
+
+  const control = await options.invoke(safeEnqueue);
+
+  Promise.resolve(control.done)
+    .then(
+      () => safeClose(),
+      (err: unknown) => {
+        safeEnqueue({ type: 'error', error: err });
+        safeClose();
+      },
+    )
+    // Belt-and-suspenders: any throw inside the handlers themselves should
+    // not become an unhandled rejection.
+    .catch(() => {});
+
+  return { stream, control };
+}

package/src/agent/internal/translate-stream-part.ts

@@ -0,0 +1,221 @@
+import type { HarnessV1StreamPart } from '../../v1';
+import type { TextStreamPart } from 'ai';
+import { generateId, type ToolSet } from '@ai-sdk/provider-utils';
+
+/**
+ * Translate one event from the harness wire format to the AI SDK
+ * `TextStreamPart` shape consumed by `streamText` callers.
+ *
+ * Most variants are close to the identity function — V4 primitives
+ * (`LanguageModelV4ToolCall`, `LanguageModelV4ToolResult`,
+ * `LanguageModelV4ToolApprovalRequest`, `LanguageModelV4FinishReason`,
+ * `LanguageModelV4Usage`) flow through unchanged. The adapters are:
+ *   - `harnessMetadata` → `providerMetadata`
+ *   - tool-call events are not translated here — validation against the
+ *     merged tool set is async and handled by `validateToolCall` in
+ *     `run-prompt.ts`
+ *   - the harness `raw` part is forwarded as the AI SDK `raw` part
+ *
+ * Returns an array of zero or more AI SDK parts. Most harness events project
+ * to a single AI SDK part; `file-change` fans out into a synthetic
+ * dynamic + provider-executed `tool-call` / `tool-result` pair so the event
+ * is observable in `streamText`-style flows without a new stream-part type
+ * needing first-class AI SDK support. Events with no consumer-facing AI SDK
+ * equivalent (`stream-start`, `finish-step`, `finish` — consumed internally)
+ * return an empty array.
+ */
+export function translateStreamPart<TOOLS extends ToolSet>(
+  event: HarnessV1StreamPart,
+): ReadonlyArray<TextStreamPart<TOOLS>> {
+  switch (event.type) {
+    case 'stream-start':
+      // The agent emits its own `start` part with normalized warnings;
+      // the harness-level start signal is consumed internally.
+      return [];
+
+    case 'text-start':
+      return [
+        {
+          type: 'text-start',
+          id: event.id,
+          providerMetadata: event.harnessMetadata,
+        } as TextStreamPart<TOOLS>,
+      ];
+
+    case 'text-delta':
+      return [
+        {
+          type: 'text-delta',
+          id: event.id,
+          text: event.delta,
+          providerMetadata: event.harnessMetadata,
+        } as TextStreamPart<TOOLS>,
+      ];
+
+    case 'text-end':
+      return [
+        {
+          type: 'text-end',
+          id: event.id,
+          providerMetadata: event.harnessMetadata,
+        } as TextStreamPart<TOOLS>,
+      ];
+
+    case 'reasoning-start':
+      return [
+        {
+          type: 'reasoning-start',
+          id: event.id,
+          providerMetadata: event.harnessMetadata,
+        } as TextStreamPart<TOOLS>,
+      ];
+
+    case 'reasoning-delta':
+      return [
+        {
+          type: 'reasoning-delta',
+          id: event.id,
+          text: event.delta,
+          providerMetadata: event.harnessMetadata,
+        } as TextStreamPart<TOOLS>,
+      ];
+
+    case 'reasoning-end':
+      return [
+        {
+          type: 'reasoning-end',
+          id: event.id,
+          providerMetadata: event.harnessMetadata,
+        } as TextStreamPart<TOOLS>,
+      ];
+
+    case 'tool-call':
+      // Tool-call validation is async (it parses input against the tool's
+      // schema) and lives in `run-prompt.ts` where the merged tool set is in
+      // scope. The translator returns nothing here — the run-prompt loop
+      // handles the emission.
+      return [];
+
+    case 'tool-approval-request':
+      return [];
+
+    case 'tool-result':
+      return [
+        {
+          type: 'tool-result',
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          input: undefined,
+          output: event.result,
+          ...(event.preliminary !== undefined
+            ? { preliminary: event.preliminary }
+            : {}),
+          ...(event.providerMetadata !== undefined
+            ? { providerMetadata: event.providerMetadata }
+            : {}),
+        } as TextStreamPart<TOOLS>,
+      ];
+
+    case 'file-change': {
+      /*
+       * `file-change` has no first-class AI SDK stream-part equivalent.
+       * Project it as a synthetic dynamic + provider-executed tool-call /
+       * tool-result pair under the reserved name `fileChange` so the event
+       * is visible to `streamText`-style consumers. `dynamic: true` keeps it
+       * out of typed-tool lookups; `providerExecuted: true` signals the
+       * runtime already executed it and the host should not dispatch.
+       */
+      const toolCallId = `harness-file-change-${generateId()}`;
+      const payload = { event: event.event, path: event.path };
+      return [
+        {
+          type: 'tool-call',
+          toolCallId,
+          toolName: 'fileChange',
+          input: payload,
+          dynamic: true,
+          providerExecuted: true,
+          ...(event.harnessMetadata !== undefined
+            ? { providerMetadata: event.harnessMetadata }
+            : {}),
+        } as TextStreamPart<TOOLS>,
+        {
+          type: 'tool-result',
+          toolCallId,
+          toolName: 'fileChange',
+          input: payload,
+          output: payload,
+          dynamic: true,
+          providerExecuted: true,
+          ...(event.harnessMetadata !== undefined
+            ? { providerMetadata: event.harnessMetadata }
+            : {}),
+        } as TextStreamPart<TOOLS>,
+      ];
+    }
+
+    case 'compaction': {
+      /*
+       * Like `file-change`, compaction has no first-class AI SDK stream-part
+       * equivalent. Project it as a synthetic dynamic + provider-executed
+       * tool-call / tool-result pair under the reserved name `compaction`, so
+       * the event is visible to `streamText`-style consumers. Compaction takes
+       * no input, so the call input is empty; the metadata rides on the result
+       * output. `dynamic: true` keeps it out of typed-tool lookups;
+       * `providerExecuted: true` signals the runtime already performed it.
+       */
+      const toolCallId = `harness-compaction-${generateId()}`;
+      const output = {
+        trigger: event.trigger,
+        summary: event.summary,
+        ...(event.tokensBefore !== undefined
+          ? { tokensBefore: event.tokensBefore }
+          : {}),
+        ...(event.tokensAfter !== undefined
+          ? { tokensAfter: event.tokensAfter }
+          : {}),
+      };
+      return [
+        {
+          type: 'tool-call',
+          toolCallId,
+          toolName: 'compaction',
+          input: {},
+          dynamic: true,
+          providerExecuted: true,
+          ...(event.harnessMetadata !== undefined
+            ? { providerMetadata: event.harnessMetadata }
+            : {}),
+        } as TextStreamPart<TOOLS>,
+        {
+          type: 'tool-result',
+          toolCallId,
+          toolName: 'compaction',
+          input: {},
+          output,
+          dynamic: true,
+          providerExecuted: true,
+          ...(event.harnessMetadata !== undefined
+            ? { providerMetadata: event.harnessMetadata }
+            : {}),
+        } as TextStreamPart<TOOLS>,
+      ];
+    }
+
+    case 'error':
+      return [{ type: 'error', error: event.error } as TextStreamPart<TOOLS>];
+
+    case 'raw':
+      return [
+        { type: 'raw', rawValue: event.rawValue } as TextStreamPart<TOOLS>,
+      ];
+
+    case 'finish-step':
+    case 'finish':
+      // finish-step / finish are consumed by the agent's result builder, not
+      // forwarded directly. The agent emits AI SDK `finish-step` / `finish`
+      // parts itself once it has assembled the surrounding step / response
+      // metadata.
+      return [];
+  }
+}