@anureo/sdk 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,1474 +0,0 @@
-// packages/core/src/runtime.ts
-import { randomUUID } from "node:crypto";
-import {
-  assertEvent,
-  assertRequest,
-  assertResult,
-  negotiateVersion,
-  supportsCapability,
-  supportsExtension,
-  validateJsonSchema
-} from "@anureo/protocol";
-
-// packages/core/src/errors.ts
-class HarnessSdkError extends Error {
-  code;
-  retryable;
-  outcomeUnknown;
-  details;
-  name = "HarnessSdkError";
-  constructor(code, message = code, retryable = false, outcomeUnknown = false, details) {
-    super(message);
-    this.code = code;
-    this.retryable = retryable;
-    this.outcomeUnknown = outcomeUnknown;
-    this.details = details;
-  }
-}
-function sdkError(cause, fallback = "HARNESS_ERROR", outcomeUnknown = false) {
-  if (cause instanceof HarnessSdkError)
-    return cause;
-  if (cause && typeof cause === "object" && "code" in cause && typeof cause.code === "string" && /^[A-Z][A-Z0-9_]{0,80}$/.test(cause.code)) {
-    return new HarnessSdkError(cause.code, cause.code, "retryable" in cause && cause.retryable === true, "outcomeUnknown" in cause ? cause.outcomeUnknown === true : outcomeUnknown);
-  }
-  return new HarnessSdkError(fallback, fallback, false, outcomeUnknown);
-}
-function waitForRequest(operation, options = {}, defaultTimeoutMs = 30000) {
-  if (options.signal?.aborted)
-    return Promise.reject(new HarnessSdkError("REQUEST_ABORTED", "Request aborted before dispatch"));
-  const timeoutMs = options.timeoutMs ?? defaultTimeoutMs;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-    return Promise.reject(new HarnessSdkError("INVALID_PARAMS", "timeoutMs must be positive"));
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const finish = (callback) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      options.signal?.removeEventListener("abort", abort);
-      callback();
-    };
-    const abort = () => finish(() => reject(new HarnessSdkError("REQUEST_ABORTED", "Request outcome is unknown after dispatch", false, true)));
-    const timer = setTimeout(() => finish(() => reject(new HarnessSdkError("REQUEST_TIMEOUT", "Request outcome is unknown after dispatch", false, true))), timeoutMs);
-    options.signal?.addEventListener("abort", abort, { once: true });
-    try {
-      operation().then((value) => finish(() => resolve(value)), (cause) => finish(() => reject(cause)));
-    } catch (cause) {
-      finish(() => reject(cause));
-    }
-  });
-}
-
-// packages/core/src/interactions.ts
-import { createHash } from "node:crypto";
-import { assertInteractionResponse } from "@anureo/protocol";
-class InteractionRegistry {
-  publish;
-  limits;
-  beforeResponse;
-  records = new Map;
-  constructor(publish, limits, beforeResponse) {
-    this.publish = publish;
-    this.limits = limits;
-    this.beforeResponse = beforeResponse;
-  }
-  get pendingCount() {
-    return [...this.records.values()].filter((record) => record.state !== "resolved").length;
-  }
-  pending() {
-    return [...this.records.values()].filter((record) => record.state === "pending").map((record) => structuredClone(record.request));
-  }
-  begin(request, responder) {
-    if (this.records.has(request.interactionId))
-      throw new HarnessSdkError("INTERACTION_ALREADY_EXISTS");
-    if (this.pendingCount >= this.limits.maxPending)
-      throw new HarnessSdkError("BACKPRESSURE_EXCEEDED", "Pending interaction limit exceeded");
-    const ttl = request.expiresAt ? Math.min(this.limits.timeoutMs, new Date(request.expiresAt).getTime() - Date.now()) : this.limits.timeoutMs;
-    if (!Number.isFinite(ttl) || ttl <= 0)
-      throw new HarnessSdkError("INTERACTION_EXPIRED");
-    if (this.records.size >= this.limits.maxPending + 1024) {
-      for (const [id, record] of this.records)
-        if (record.state === "resolved") {
-          this.records.delete(id);
-          break;
-        }
-    }
-    const result = new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.cancel(request.interactionId, "timeout", "expired").catch(() => {});
-      }, ttl);
-      timer.unref?.();
-      this.records.set(request.interactionId, { request: structuredClone(request), responder, state: "pending", timer, resolve, reject });
-    });
-    result.catch(() => {});
-    return result;
-  }
-  async respond(id, requestId, response) {
-    const record = this.records.get(id);
-    if (!record)
-      throw new HarnessSdkError("INTERACTION_EXPIRED");
-    assertInteractionResponse(record.request, response);
-    this.beforeResponse?.(record.request, response);
-    const fingerprint = createHash("sha256").update(JSON.stringify(response)).digest("hex");
-    if (record.responseRequestId === requestId && record.responseFingerprint === fingerprint && record.responseOperation)
-      return record.responseOperation;
-    if (record.state !== "pending")
-      throw new HarnessSdkError("INTERACTION_ALREADY_RESOLVED");
-    record.state = "responding";
-    record.responseRequestId = requestId;
-    record.responseFingerprint = fingerprint;
-    clearTimeout(record.timer);
-    record.responseOperation = (async () => {
-      try {
-        await waitForRequest(() => record.responder(response), { timeoutMs: this.limits.responseTimeoutMs ?? 30000 });
-        if (record.state === "resolved")
-          throw new HarnessSdkError("RESULT_UNKNOWN", "Interaction ended while response was in flight", false, true);
-        const result = { interactionId: id, outcome: "responded" };
-        record.state = "resolved";
-        await this.publish(result);
-        record.resolve(response);
-        return result;
-      } catch (cause) {
-        const error = sdkError(cause, "RESULT_UNKNOWN", true);
-        if (record.state !== "resolved") {
-          record.state = "resolved";
-          await this.publish({ interactionId: id, outcome: "unknown", reason: error.code });
-        }
-        record.reject(error);
-        throw error;
-      }
-    })();
-    return record.responseOperation;
-  }
-  async cancel(id, reason = "cancelled", outcome = "cancelled") {
-    const record = this.records.get(id);
-    if (!record)
-      throw new HarnessSdkError("INTERACTION_EXPIRED");
-    if (record.state === "resolved")
-      throw new HarnessSdkError("INTERACTION_ALREADY_RESOLVED");
-    if (record.state === "responding") {
-      if (reason === "cancelled")
-        throw new HarnessSdkError("INTERACTION_ALREADY_RESOLVED");
-      record.state = "resolved";
-      clearTimeout(record.timer);
-      const result = { interactionId: id, outcome: "unknown", reason };
-      try {
-        await this.publish(result);
-      } finally {
-        record.reject(new HarnessSdkError("RESULT_UNKNOWN", "Interaction ended while response was in flight", false, true));
-      }
-      return result;
-    }
-    record.state = "responding";
-    clearTimeout(record.timer);
-    try {
-      await waitForRequest(() => record.responder(null, reason), { timeoutMs: this.limits.responseTimeoutMs ?? 30000 });
-    } catch {
-      outcome = "unknown";
-    }
-    record.state = "resolved";
-    const result = { interactionId: id, outcome, reason };
-    try {
-      await this.publish(result);
-    } finally {
-      record.reject(new HarnessSdkError(outcome === "unknown" ? "RESULT_UNKNOWN" : "INTERACTION_CANCELLED", "Interaction is no longer actionable", false, outcome === "unknown"));
-    }
-    return result;
-  }
-  async cancelAll(reason, turnId) {
-    const ids = [...this.records].filter(([, record]) => record.state !== "resolved" && (turnId === undefined || record.request.turnId === turnId)).map(([id]) => id);
-    await Promise.allSettled(ids.map((id) => this.cancel(id, reason, reason === "connection_lost" ? "unknown" : "cancelled")));
-  }
-  async resolveExternally(result) {
-    const record = this.records.get(result.interactionId);
-    if (!record || record.state === "resolved")
-      return;
-    record.state = "resolved";
-    clearTimeout(record.timer);
-    try {
-      await this.publish(result);
-    } finally {
-      record.reject(new HarnessSdkError(result.outcome === "unknown" ? "RESULT_UNKNOWN" : "INTERACTION_ALREADY_RESOLVED", "Interaction was resolved by the native peer", false, result.outcome === "unknown"));
-    }
-  }
-}
-
-// packages/core/src/queue.ts
-class BoundedEventQueue {
-  sizeOf;
-  entries = [];
-  bytes = 0;
-  reader;
-  waiting;
-  controls = [];
-  ended = false;
-  failure;
-  writers = new Set;
-  limits;
-  constructor(limits = {}, sizeOf = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength) {
-    this.sizeOf = sizeOf;
-    this.limits = { maxEvents: limits.maxEvents ?? 2048, maxBytes: limits.maxBytes ?? 16 * 1024 * 1024, maxFrameBytes: limits.maxFrameBytes ?? 8 * 1024 * 1024, maxWaitingWriters: limits.maxWaitingWriters ?? 32, maxControlEvents: limits.maxControlEvents ?? 33 };
-    if (Object.values(this.limits).some((n) => !Number.isSafeInteger(n) || n <= 0))
-      throw new HarnessSdkError("INVALID_PARAMS", "Queue limits must be positive integers");
-  }
-  get bufferedEvents() {
-    return this.entries.length + this.controls.length;
-  }
-  get bufferedBytes() {
-    return this.bytes;
-  }
-  wakeWriters() {
-    for (const wake of this.writers)
-      wake();
-    this.writers.clear();
-  }
-  assertOpen() {
-    if (this.ended)
-      throw this.failure ?? new HarnessSdkError("STREAM_CLOSED");
-  }
-  checkedSize(value) {
-    const bytes = this.sizeOf(value);
-    if (bytes > this.limits.maxFrameBytes || bytes > this.limits.maxBytes)
-      throw new HarnessSdkError("FRAME_TOO_LARGE");
-    return bytes;
-  }
-  assertWritable(value) {
-    this.assertOpen();
-    const bytes = this.checkedSize(value);
-    if (!this.waiting && (this.entries.length >= this.limits.maxEvents || this.bytes + bytes > this.limits.maxBytes))
-      throw new HarnessSdkError("BACKPRESSURE_EXCEEDED");
-  }
-  push(value) {
-    this.assertWritable(value);
-    const bytes = this.checkedSize(value);
-    if (this.waiting) {
-      const waiting = this.waiting;
-      this.waiting = undefined;
-      waiting.resolve({ done: false, value });
-      return;
-    }
-    this.entries.push({ value, bytes });
-    this.bytes += bytes;
-  }
-  async write(value, accepted) {
-    const bytes = this.checkedSize(value);
-    while (!this.waiting && (this.entries.length >= this.limits.maxEvents || this.bytes + bytes > this.limits.maxBytes)) {
-      this.assertOpen();
-      if (this.writers.size >= this.limits.maxWaitingWriters)
-        throw new HarnessSdkError("BACKPRESSURE_EXCEEDED");
-      await new Promise((resolve) => this.writers.add(resolve));
-    }
-    this.push(value);
-    accepted?.();
-  }
-  pushControl(value) {
-    this.assertOpen();
-    this.checkedSize(value);
-    if (this.waiting) {
-      const waiter = this.waiting;
-      this.waiting = undefined;
-      waiter.resolve({ done: false, value });
-    } else {
-      if (this.controls.length >= this.limits.maxControlEvents)
-        throw new HarnessSdkError("BACKPRESSURE_EXCEEDED", "Control event limit exceeded");
-      this.controls.push(value);
-    }
-  }
-  endWithControl(value) {
-    if (this.ended)
-      return;
-    this.pushControl(value);
-    this.end();
-  }
-  end(cause) {
-    if (this.ended)
-      return;
-    this.ended = true;
-    this.failure = cause;
-    this.wakeWriters();
-    if (this.waiting) {
-      const waiter = this.waiting;
-      this.waiting = undefined;
-      cause ? waiter.reject(cause) : waiter.resolve({ done: true, value: undefined });
-    }
-  }
-  [Symbol.asyncIterator]() {
-    if (this.reader)
-      throw new HarnessSdkError("EVENT_STREAM_ALREADY_OWNED");
-    const reader = Symbol("reader");
-    this.reader = reader;
-    let detached = false;
-    const detach = () => {
-      detached = true;
-      if (this.reader === reader)
-        this.reader = undefined;
-      if (this.waiting?.reader === reader) {
-        const waiter = this.waiting;
-        this.waiting = undefined;
-        waiter.resolve({ done: true, value: undefined });
-      }
-      return { done: true, value: undefined };
-    };
-    return {
-      next: () => {
-        if (detached)
-          return Promise.resolve({ done: true, value: undefined });
-        const entry = this.entries.shift();
-        if (entry) {
-          this.bytes -= entry.bytes;
-          this.wakeWriters();
-          return Promise.resolve({ done: false, value: entry.value });
-        }
-        if (this.controls.length)
-          return Promise.resolve({ done: false, value: this.controls.shift() });
-        if (this.ended) {
-          detach();
-          return this.failure ? Promise.reject(this.failure) : Promise.resolve({ done: true, value: undefined });
-        }
-        if (this.waiting)
-          return Promise.reject(new HarnessSdkError("CONCURRENT_EVENT_READ"));
-        return new Promise((resolve, reject) => {
-          this.waiting = { reader, resolve, reject };
-          this.wakeWriters();
-        });
-      },
-      return: async () => detach(),
-      throw: async (cause) => {
-        detach();
-        throw cause;
-      }
-    };
-  }
-}
-
-// packages/core/src/file-change-limits.ts
-var FILE_CHANGE_MATERIAL_LIMIT = 50;
-var FILE_CHANGE_TEXT_LIMIT = 256 * 1024;
-function boundFileChangeItem(item) {
-  if (item.type !== "toolCall" || item.fileChanges === undefined)
-    return item;
-  let bytes = FILE_CHANGE_TEXT_LIMIT, materials = 0, truncated = false;
-  const encoder = new TextEncoder;
-  const take = (value) => {
-    const encoded = encoder.encode(value);
-    if (encoded.byteLength <= bytes) {
-      bytes -= encoded.byteLength;
-      return { value, complete: true };
-    }
-    let prefix = new TextDecoder().decode(encoded.subarray(0, bytes));
-    const end = prefix.lastIndexOf(`
-`);
-    prefix = end < 0 ? "" : prefix.slice(0, end + 1);
-    bytes -= encoder.encode(prefix).byteLength;
-    truncated = true;
-    return { value: prefix, complete: false };
-  };
-  const fileChanges = item.fileChanges.map((change) => {
-    let partial = false;
-    const next = [];
-    for (const material of change.materials) {
-      if (material.format === "unavailable") {
-        next.push(material);
-        continue;
-      }
-      if (++materials > FILE_CHANGE_MATERIAL_LIMIT) {
-        partial = truncated = true;
-        continue;
-      }
-      if (material.format === "unified") {
-        const patch = take(material.patch);
-        partial ||= !patch.complete;
-        next.push(patch.value ? { ...material, patch: patch.value } : { format: "unavailable", reason: "tooLarge" });
-      } else {
-        const oldText = material.oldText === null ? null : take(material.oldText);
-        const newText = take(material.newText);
-        if (oldText !== null && !oldText.complete || !newText.complete) {
-          partial = true;
-          next.push({ format: "unavailable", reason: "tooLarge" });
-        } else
-          next.push({ ...material, oldText: oldText === null ? null : oldText.value, newText: newText.value });
-      }
-    }
-    if (!next.length && change.materials.length)
-      next.push({ format: "unavailable", reason: "tooLarge" });
-    return { ...change, materials: next, ...partial ? { completeness: "partial", ...change.stats ? { stats: { ...change.stats, accuracy: "partial" } } : {} } : {} };
-  });
-  const mirror = (value) => {
-    if (typeof value === "string")
-      return take(value).value;
-    if (Array.isArray(value))
-      return value.map(mirror);
-    if (value && typeof value === "object")
-      return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, mirror(child)]));
-    return value;
-  };
-  const result = { ...item, fileChanges, ...item.input !== undefined ? { input: mirror(item.input) } : {}, ...item.output !== undefined ? { output: mirror(item.output) } : {}, ...item.raw !== undefined ? { raw: mirror(item.raw) } : {}, ...item.extensions ? { extensions: mirror(item.extensions) } : {} };
-  if (truncated)
-    result.extensions = { ...result.extensions, "x-anureo/fileChangesTruncated": true };
-  return result;
-}
-
-// packages/core/src/secrets.ts
-import { assertDefinition } from "@anureo/protocol";
-class SecretRedactor {
-  onRemember;
-  values = new Set;
-  streams = new Map;
-  secretBytes = 0;
-  constructor(onRemember) {
-    this.onRemember = onRemember;
-  }
-  remember(value) {
-    if (value === undefined || value === null)
-      return;
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      const text = String(value);
-      if (text && !this.values.has(text)) {
-        const bytes = new TextEncoder().encode(text).byteLength;
-        if (this.values.size >= 128 || this.secretBytes + bytes > 64 * 1024)
-          throw new HarnessSdkError("BACKPRESSURE_EXCEEDED", "Marked secret limit exceeded");
-        this.onRemember?.(text);
-        this.values.add(text);
-        this.secretBytes += bytes;
-      }
-    } else if (Array.isArray(value))
-      value.forEach((entry) => this.remember(entry));
-    else
-      for (const entry of Object.values(value))
-        this.remember(entry);
-  }
-  rememberResponse(request, response) {
-    if (request.kind === "userInput" && response.kind === "userInput") {
-      for (const question of request.questions)
-        if (question.secret)
-          this.remember(response.answers[question.id]);
-    }
-    if (request.kind === "elicitation" && response.kind === "elicitation" && response.content && request.schema !== undefined)
-      this.fromSchema(request.schema, response.content, request.schema);
-    if (request.kind === "dynamicTool" && response.kind === "dynamicTool" && request.schema !== undefined)
-      this.fromSchema(request.schema, response, request.schema);
-  }
-  fromSchema(schema, value, root, depth = 0) {
-    if (depth > 32 || typeof schema !== "object" || !schema || value === undefined)
-      return;
-    if (schema.writeOnly === true || schema.secret === true) {
-      this.remember(value);
-      return;
-    }
-    if (typeof schema.$ref === "string" && schema.$ref.startsWith("#/") && typeof root === "object") {
-      let target = root;
-      for (const token of schema.$ref.slice(2).split("/")) {
-        const key = token.replace(/~1/g, "/").replace(/~0/g, "~");
-        target = target && typeof target === "object" && !Array.isArray(target) ? target[key] : undefined;
-      }
-      if (typeof target === "boolean" || target && typeof target === "object" && !Array.isArray(target))
-        this.fromSchema(target, value, root, depth + 1);
-    }
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      const properties = schema.properties;
-      if (properties && typeof properties === "object" && !Array.isArray(properties)) {
-        for (const [key, child] of Object.entries(properties))
-          if (typeof child === "boolean" || child && typeof child === "object" && !Array.isArray(child))
-            this.fromSchema(child, value[key], root, depth + 1);
-      }
-      if (schema.additionalProperties && typeof schema.additionalProperties === "object" && !Array.isArray(schema.additionalProperties)) {
-        for (const [key, child] of Object.entries(value))
-          if (!properties || typeof properties !== "object" || !Object.hasOwn(properties, key))
-            this.fromSchema(schema.additionalProperties, child, root, depth + 1);
-      }
-    }
-    if (Array.isArray(value) && schema.items && (typeof schema.items === "boolean" || typeof schema.items === "object" && !Array.isArray(schema.items)))
-      for (const child of value)
-        this.fromSchema(schema.items, child, root, depth + 1);
-    for (const key of ["allOf", "anyOf", "oneOf"])
-      if (Array.isArray(schema[key])) {
-        for (const branch of schema[key])
-          if (typeof branch === "boolean" || branch && typeof branch === "object" && !Array.isArray(branch))
-            this.fromSchema(branch, value, root, depth + 1);
-      }
-  }
-  scan(value, final) {
-    const values = [...this.values].sort((a, b) => b.length - a.length);
-    const output = [];
-    for (let offset = 0;offset < value.length; ) {
-      const candidates = values.filter((secret) => secret[0] === value[offset]);
-      const secret = candidates.find((entry) => value.startsWith(entry, offset));
-      if (secret) {
-        output.push("[redacted]");
-        offset += secret.length;
-        continue;
-      }
-      const remaining = value.slice(offset);
-      if (!final && candidates.some((entry) => entry.startsWith(remaining)))
-        return { text: output.join(""), pending: remaining };
-      output.push(value[offset]);
-      offset++;
-    }
-    return { text: output.join(""), pending: "" };
-  }
-  text(value) {
-    return this.values.size ? this.scan(value, true).text : value;
-  }
-  delta(stream, value) {
-    if (!this.values.size)
-      return value;
-    const result = this.scan((this.streams.get(stream) ?? "") + value, false);
-    if (result.pending)
-      this.streams.set(stream, result.pending);
-    else
-      this.streams.delete(stream);
-    return result.text;
-  }
-  json(value) {
-    if (typeof value === "string")
-      return this.text(value);
-    if (typeof value === "number" || typeof value === "boolean")
-      return this.values.has(String(value)) ? "[redacted]" : value;
-    if (Array.isArray(value))
-      return value.map((entry) => this.json(entry));
-    if (value && typeof value === "object")
-      return Object.fromEntries(Object.entries(value).map(([key, child]) => [this.text(key), this.json(child)]));
-    return value;
-  }
-  schema(schema) {
-    if (typeof schema === "boolean")
-      return schema;
-    const output = { ...schema };
-    for (const key of ["title", "description", "default", "examples"])
-      if (output[key] !== undefined)
-        output[key] = this.json(output[key]);
-    for (const key of ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]) {
-      const map = output[key];
-      if (map && typeof map === "object" && !Array.isArray(map))
-        output[key] = Object.fromEntries(Object.entries(map).map(([name, child]) => [name, typeof child === "boolean" || child && typeof child === "object" && !Array.isArray(child) ? this.schema(child) : child]));
-    }
-    for (const key of ["additionalProperties", "unevaluatedProperties", "propertyNames", "items", "contains", "additionalItems", "unevaluatedItems", "not", "if", "then", "else", "contentSchema"]) {
-      const child = output[key];
-      if (typeof child === "boolean" || child && typeof child === "object" && !Array.isArray(child))
-        output[key] = this.schema(child);
-    }
-    for (const key of ["allOf", "anyOf", "oneOf", "prefixItems"]) {
-      const children = output[key];
-      if (Array.isArray(children))
-        output[key] = children.map((child) => typeof child === "boolean" || child && typeof child === "object" && !Array.isArray(child) ? this.schema(child) : child);
-    }
-    return output;
-  }
-  capabilities(value) {
-    if (!value.config)
-      return value;
-    return { ...value, config: { ...value.config, options: value.config.options.map((option) => ({ ...option, ...option.title !== undefined ? { title: this.text(option.title) } : {}, ...option.value !== undefined ? { value: this.json(option.value) } : {}, schema: this.schema(option.schema) })) } };
-  }
-  goal(value) {
-    return { ...value, goal: value.goal === null ? null : this.json(value.goal) };
-  }
-  state(value) {
-    return { ...value, ...value.metadata ? { metadata: this.json(value.metadata) } : {}, config: Object.fromEntries(Object.entries(value.config).map(([id, entry]) => [id, this.json(entry)])), capabilities: this.capabilities(value.capabilities), ...value.goal ? { goal: this.goal(value.goal) } : {} };
-  }
-  result(method, value) {
-    if (method === "session/config/set")
-      return this.state(value);
-    if (method === "goal/set" || method === "goal/clear")
-      return this.goal(value);
-    return value;
-  }
-  input(block) {
-    if (block.type === "text")
-      return { ...block, text: this.text(block.text) };
-    if (block.type === "file")
-      return { ...block, uri: this.text(block.uri), ...block.name ? { name: this.text(block.name) } : {} };
-    return { ...block, ...block.url ? { url: this.text(block.url) } : {}, ...block.data ? { data: this.text(block.data) } : {} };
-  }
-  item(item) {
-    if (item.extensions)
-      item = { ...item, extensions: this.json(item.extensions) };
-    switch (item.type) {
-      case "agentMessage":
-        return { ...item, text: this.text(item.text) };
-      case "userMessage":
-        return { ...item, content: item.content.map((block) => this.input(block)) };
-      case "reasoning":
-        return { ...item, ...item.text ? { text: this.text(item.text) } : {}, ...item.summary ? { summary: this.text(item.summary) } : {} };
-      case "toolCall":
-        return boundFileChangeItem({ ...item, ...item.image ? { image: { ...item.image, ...item.image.path ? { path: this.text(item.image.path) } : {}, ...item.image.revisedPrompt ? { revisedPrompt: this.text(item.image.revisedPrompt) } : {} } } : {}, ...item.fileChanges !== undefined ? { fileChanges: item.fileChanges.map((change) => ({ ...change, path: this.text(change.path), ...change.oldPath !== undefined ? { oldPath: this.text(change.oldPath) } : {}, materials: change.materials.map((material) => material.format === "unified" ? { ...material, patch: this.text(material.patch) } : material.format === "text" ? { ...material, oldText: material.oldText === null ? null : this.text(material.oldText), newText: this.text(material.newText) } : material) })) } : {}, title: this.text(item.title), ...item.input !== undefined ? { input: this.json(item.input) } : {}, ...item.output !== undefined ? { output: this.json(item.output) } : {}, ...item.raw !== undefined ? { raw: this.json(item.raw) } : {}, ...item.locations ? { locations: item.locations.map((location) => ({ ...location, path: this.text(location.path) })) } : {} });
-      case "plan":
-        return { ...item, steps: item.steps.map((step) => ({ ...step, text: this.text(step.text) })) };
-      case "subagent":
-        return { ...item, ...item.name ? { name: this.text(item.name) } : {}, ...item.task ? { task: this.text(item.task) } : {} };
-      case "review":
-        return { ...item, ...item.text ? { text: this.text(item.text) } : {} };
-      case "compaction":
-        return { ...item, ...item.summary ? { summary: this.text(item.summary) } : {} };
-      case "hook":
-        return { ...item, name: this.text(item.name), ...item.input !== undefined ? { input: this.json(item.input) } : {}, ...item.output !== undefined ? { output: this.json(item.output) } : {} };
-      case "notice":
-        return { ...item, text: this.text(item.text) };
-    }
-  }
-  interaction(request) {
-    const common = { ...request, ...request.title ? { title: this.text(request.title) } : {}, ...request.privatePayload ? { privatePayload: this.json(request.privatePayload) } : {} };
-    switch (common.kind) {
-      case "approval":
-        return { ...common, ...common.input !== undefined ? { input: this.json(common.input) } : {}, options: common.options.map((option) => ({ ...option, label: this.text(option.label), ...option.description ? { description: this.text(option.description) } : {} })) };
-      case "userInput":
-        return { ...common, questions: common.questions.map((question) => ({ ...question, prompt: this.text(question.prompt), ...question.options ? { options: question.options.map((option) => ({ ...option, label: this.text(option.label) })) } : {} })) };
-      case "elicitation":
-        return { ...common, ...common.message ? { message: this.text(common.message) } : {} };
-      case "dynamicTool":
-        return { ...common, arguments: this.json(common.arguments) };
-    }
-  }
-  deltaValue(kind, value) {
-    if (kind === "patch" && value && typeof value === "object" && !Array.isArray(value) && (("type" in value) || ("fileChanges" in value))) {
-      assertDefinition("Item", value);
-      return this.item(value);
-    }
-    return this.json(value);
-  }
-  event(event) {
-    switch (event.type) {
-      case "item/started":
-      case "item/completed": {
-        if (event.type === "item/completed")
-          this.streams.delete(event.payload.item.id);
-        return { ...event, payload: { item: this.item(event.payload.item) } };
-      }
-      case "item/delta":
-        return { ...event, payload: { ...event.payload, ...event.payload.text !== undefined ? { text: this.delta(event.payload.itemId, event.payload.text) } : {}, ...event.payload.value !== undefined ? { value: this.deltaValue(event.payload.kind, event.payload.value) } : {} } };
-      case "notice":
-        return { ...event, payload: { ...event.payload, message: this.text(event.payload.message), ...event.payload.raw !== undefined ? { raw: this.json(event.payload.raw) } : {} } };
-      case "extension":
-        return { ...event, payload: { ...event.payload, data: this.json(event.payload.data) } };
-      case "session/metadata":
-        return { ...event, payload: this.json(event.payload) };
-      case "session/state":
-        return { ...event, payload: this.state(event.payload) };
-      case "interaction/requested":
-        return { ...event, payload: this.interaction(event.payload) };
-      case "turn/completed":
-        return { ...event, payload: { ...event.payload, ...event.payload.error ? { error: { ...event.payload.error, message: this.text(event.payload.error.message), ...event.payload.error.details ? { details: this.json(event.payload.error.details) } : {} } } : {} } };
-      default:
-        return event;
-    }
-  }
-  history(page) {
-    return { ...page, items: page.items.map((entry) => ({ ...entry, item: this.item(entry.item) })) };
-  }
-}
-
-// packages/core/src/runtime.ts
-function immutable(value) {
-  const copy = structuredClone(value);
-  const freeze = (entry) => {
-    if (entry && typeof entry === "object") {
-      for (const child of Object.values(entry))
-        freeze(child);
-      Object.freeze(entry);
-    }
-  };
-  freeze(copy);
-  return copy;
-}
-function wireError(cause) {
-  const error = sdkError(cause, "PROTOCOL_ERROR", true);
-  return { code: error.code, message: error.code, retryable: error.retryable, outcomeUnknown: error.outcomeUnknown };
-}
-
-class ManagedHarnessSession {
-  options;
-  clientCapabilities;
-  _binding;
-  _capabilities;
-  queue;
-  interactions;
-  streamId;
-  seq = 0;
-  activeTurnId;
-  started = new Set;
-  ended = new Set;
-  deliveredStarted = new Set;
-  deliveredEnded = new Set;
-  items = new Map;
-  backend;
-  closed = false;
-  recovering = false;
-  controlBusy = false;
-  maintenancePending = false;
-  emitter = Promise.resolve();
-  pendingEmissions = 0;
-  disposePromise;
-  failurePromise;
-  failureCause;
-  emergencyPublication = false;
-  backendDisposal;
-  requests = new Map;
-  state;
-  createId;
-  secrets;
-  constructor(binding, capabilities, options = {}, initial, clientCapabilities) {
-    this.options = options;
-    this.clientCapabilities = clientCapabilities;
-    this.createId = options.createId ?? randomUUID;
-    this._binding = immutable(binding);
-    this._capabilities = immutable(capabilities);
-    this.secrets = new SecretRedactor((value) => this.options.onMarkedSecret?.(this.binding, value));
-    this.streamId = this.createId();
-    this.queue = new BoundedEventQueue({ ...options.queue, maxControlEvents: (options.maxPendingInteractions ?? 32) + 1 });
-    this.state = { binding: structuredClone(binding), capabilities: structuredClone(capabilities), config: structuredClone(initial?.config ?? {}), ...initial?.model ? { model: initial.model } : {}, status: "opening", capabilityRevision: 1 };
-    this.interactions = new InteractionRegistry(async (payload) => {
-      const event = { type: "interaction/resolved", payload };
-      if (this.emergencyPublication) {
-        this.queue.pushControl(this.makeEvent(event, {}));
-        this.seq++;
-      } else
-        await this.emit(event);
-    }, { maxPending: options.maxPendingInteractions ?? 32, timeoutMs: options.interactionTimeoutMs ?? 600000, responseTimeoutMs: options.requestTimeoutMs }, (request, response) => this.secrets.rememberResponse(request, response));
-  }
-  get binding() {
-    return this._binding;
-  }
-  get capabilities() {
-    return this._capabilities;
-  }
-  get isClosed() {
-    return this.closed;
-  }
-  get snapshot() {
-    return this.secrets.state(structuredClone(this.state));
-  }
-  events() {
-    return this.queue;
-  }
-  reserveFork(binding) {
-    this.requireBackend();
-    if (binding.adapterId !== this.binding.adapterId || binding.runtimeConfigId !== this.binding.runtimeConfigId)
-      throw new HarnessSdkError("SESSION_BINDING_MISMATCH");
-    if (this.activeTurnId || this.controlBusy || this.maintenancePending)
-      throw new HarnessSdkError("SESSION_BUSY");
-    this.controlBusy = true;
-    return () => {
-      this.controlBusy = false;
-    };
-  }
-  async attach(backend) {
-    if (this.backend)
-      throw new HarnessSdkError("PROTOCOL_ERROR", "Backend already attached");
-    for (const key of ["sessionId", "adapterId", "runtimeConfigId"])
-      if (backend.binding[key] !== this.binding[key])
-        throw new HarnessSdkError("SESSION_BINDING_MISMATCH");
-    if (this.closed) {
-      await backend.dispose();
-      throw this.failureCause ?? new HarnessSdkError("STREAM_CLOSED", "Session closed before backend attachment", false, true);
-    }
-    this.backend = backend;
-    this._binding = immutable(backend.binding);
-    this._capabilities = immutable(backend.capabilities);
-    this.state = { ...this.state, binding: structuredClone(backend.binding), capabilities: structuredClone(backend.capabilities), status: this.activeTurnId ? "running" : "ready" };
-    await this.emit({ type: "session/state", payload: this.snapshot });
-  }
-  makeEvent(payload, scope) {
-    payload = this.secrets.event(payload);
-    const turnId = scope.turnId ?? (payload.type === "turn/started" || payload.type === "turn/completed" ? payload.payload.turnId : undefined);
-    const itemId = scope.itemId ?? (payload.type === "item/delta" ? payload.payload.itemId : payload.type === "item/started" || payload.type === "item/completed" ? payload.payload.item.id : undefined);
-    const event = { sessionId: this.binding.sessionId, streamId: this.streamId, seq: this.seq + 1, timestamp: (this.options.now ?? (() => new Date().toISOString()))(), ...scope, ...turnId ? { turnId } : {}, ...itemId ? { itemId } : {}, ...payload };
-    assertEvent(event);
-    return event;
-  }
-  prepare(payload, scope) {
-    if (payload.type === "turn/started") {
-      const id = payload.payload.turnId;
-      if (this.ended.has(id) || this.started.has(id))
-        return false;
-      if (this.activeTurnId && this.activeTurnId !== id)
-        throw new HarnessSdkError("PROTOCOL_ERROR", "Concurrent native turns");
-      this.activeTurnId = id;
-      this.started.add(id);
-      this.state.status = "running";
-      this.state.activeTurnId = id;
-    } else if (payload.type === "turn/completed") {
-      const id = payload.payload.turnId;
-      if (this.ended.has(id))
-        return false;
-      if (!this.started.has(id))
-        throw new HarnessSdkError("PROTOCOL_ERROR", "Turn completed without started");
-      this.ended.add(id);
-      if (this.activeTurnId === id) {
-        this.activeTurnId = undefined;
-        delete this.state.activeTurnId;
-        this.state.status = this.recovering ? "recoveryRequired" : "ready";
-      }
-    } else if (payload.type === "item/started" || payload.type === "item/completed" || payload.type === "item/delta") {
-      const turnId = scope.turnId;
-      if (!turnId || !this.started.has(turnId) || this.ended.has(turnId))
-        throw new HarnessSdkError("PROTOCOL_ERROR", "Item outside an active turn");
-      const itemId = payload.type === "item/delta" ? payload.payload.itemId : payload.payload.item.id;
-      const key = JSON.stringify([turnId, itemId]);
-      const previous = this.items.get(key);
-      if (payload.type === "item/started") {
-        if (previous)
-          throw new HarnessSdkError("PROTOCOL_ERROR", "Duplicate item started");
-        this.items.set(key, { item: structuredClone(payload.payload.item), completed: false });
-      } else if (payload.type === "item/completed") {
-        if (previous?.completed)
-          return false;
-        this.items.set(key, { item: structuredClone(payload.payload.item), completed: true });
-      } else if (!previous || previous.completed)
-        throw new HarnessSdkError("PROTOCOL_ERROR", "Delta without an open item");
-    } else if (payload.type === "session/state") {
-      if (payload.payload.binding.sessionId !== this.binding.sessionId || payload.payload.binding.adapterId !== this.binding.adapterId || payload.payload.binding.runtimeConfigId !== this.binding.runtimeConfigId)
-        throw new HarnessSdkError("SESSION_BINDING_MISMATCH");
-      this.state = { ...structuredClone(payload.payload), metadata: { ...this.state.metadata, ...structuredClone(payload.payload.metadata) } };
-      this._capabilities = immutable(payload.payload.capabilities);
-      this._binding = immutable(payload.payload.binding);
-      if (["ready", "closed"].includes(payload.payload.status) && !this.activeTurnId)
-        this.maintenancePending = false;
-    } else if (payload.type === "session/metadata") {
-      this.state.metadata = { ...this.state.metadata, ...structuredClone(payload.payload) };
-    } else if (payload.type === "extension" && !supportsExtension(this.capabilities, payload.payload.name, payload.payload.version))
-      throw new HarnessSdkError("CAPABILITY_UNSUPPORTED");
-    return true;
-  }
-  accepted(payload) {
-    this.seq++;
-    if (payload.type === "turn/started")
-      this.deliveredStarted.add(payload.payload.turnId);
-    if (payload.type === "turn/completed")
-      this.deliveredEnded.add(payload.payload.turnId);
-  }
-  emit(payload, scope = {}) {
-    if (this.closed)
-      return Promise.reject(new HarnessSdkError("STREAM_CLOSED"));
-    if (++this.pendingEmissions > (this.options.queue?.maxWaitingWriters ?? 32)) {
-      this.pendingEmissions--;
-      const error = new HarnessSdkError("BACKPRESSURE_EXCEEDED");
-      this.fail(error);
-      return Promise.reject(error);
-    }
-    const task = this.emitter.then(async () => {
-      if (!this.prepare(payload, scope))
-        return;
-      const event = this.makeEvent(payload, scope);
-      await this.queue.write(event, () => this.accepted(payload));
-      if (payload.type === "turn/completed")
-        this.interactions.cancelAll("turn_ended", payload.payload.turnId);
-    });
-    this.emitter = task.catch(() => {});
-    return task.catch(async (cause) => {
-      await this.fail(cause);
-      throw cause;
-    }).finally(() => {
-      this.pendingEmissions--;
-    });
-  }
-  tryEmit(payload, scope = {}) {
-    try {
-      if (this.closed)
-        return false;
-      if (this.pendingEmissions > 0)
-        throw new HarnessSdkError("BACKPRESSURE_EXCEEDED");
-      const event = this.makeEvent(payload, scope);
-      this.queue.assertWritable(event);
-      if (!this.prepare(payload, scope))
-        return true;
-      this.queue.push(event);
-      this.accepted(payload);
-      if (payload.type === "turn/completed")
-        this.interactions.cancelAll("turn_ended", payload.payload.turnId);
-      return true;
-    } catch (cause) {
-      this.fail(cause);
-      return false;
-    }
-  }
-  async requestInteraction(request, responder) {
-    if (!this.capabilities.interactions?.includes(request.kind) || !this.clientCapabilities?.interactions?.includes(request.kind)) {
-      await responder(null, "unsupported").catch(() => {});
-      throw new HarnessSdkError("INTERACTION_UNSUPPORTED");
-    }
-    let result;
-    try {
-      result = this.interactions.begin(request, responder);
-    } catch (cause) {
-      await responder(null, "interaction_rejected").catch(() => {});
-      throw cause;
-    }
-    await this.emit({ type: "interaction/requested", payload: request }, { turnId: request.turnId, itemId: request.itemId });
-    return result;
-  }
-  async resolveInteraction(result) {
-    assertResult("interaction/respond", result);
-    await this.interactions.resolveExternally(result);
-  }
-  fail(cause) {
-    return this.failurePromise ??= this.performFailure(cause);
-  }
-  async performFailure(cause) {
-    if (this.closed)
-      return;
-    this.failureCause = sdkError(cause, "STREAM_FAILED", true);
-    this.closed = true;
-    this.recovering = true;
-    this.state.status = "recoveryRequired";
-    const error = wireError(cause);
-    const turnId = this.activeTurnId ?? [...this.deliveredStarted].find((id) => !this.deliveredEnded.has(id));
-    this.emergencyPublication = true;
-    await this.interactions.cancelAll("connection_lost");
-    if (turnId && this.deliveredStarted.has(turnId) && !this.deliveredEnded.has(turnId)) {
-      this.ended.add(turnId);
-      this.activeTurnId = undefined;
-      const event = this.makeEvent({ type: "turn/completed", payload: { turnId, status: "failed", error } }, { turnId });
-      this.accepted(event);
-      this.queue.endWithControl(event);
-    } else
-      this.queue.end(sdkError(cause, "STREAM_FAILED", true));
-    await this.disposeBackend().catch(() => {});
-  }
-  requireBackend(method) {
-    if (this.recovering && method !== "history/read" && method !== "turn/interrupt")
-      throw new HarnessSdkError("RECOVERY_REQUIRED");
-    if (this.closed)
-      throw new HarnessSdkError("SESSION_CLOSED");
-    if (!this.backend)
-      throw new HarnessSdkError("SESSION_NOT_READY");
-    return this.backend;
-  }
-  guard(method, params) {
-    assertRequest(method, params);
-    if (params.sessionId !== this.binding.sessionId)
-      throw new HarnessSdkError("SESSION_BINDING_MISMATCH");
-    const unsupported = () => {
-      throw new HarnessSdkError("CAPABILITY_UNSUPPORTED");
-    };
-    if (method === "turn/steer" && !supportsCapability(this.capabilities, "turn.steer"))
-      unsupported();
-    if (method === "turn/interrupt" && !supportsCapability(this.capabilities, "turn.interrupt"))
-      unsupported();
-    if (method === "session/revert" && !supportsCapability(this.capabilities, "session.revert", params.scope))
-      unsupported();
-    if (method === "history/read" && !supportsCapability(this.capabilities, "session.history"))
-      unsupported();
-    if ((method === "goal/set" || method === "goal/clear") && !supportsCapability(this.capabilities, "goal.actions", method.split("/")[1]))
-      unsupported();
-    if (method === "compact/start" && !this.capabilities.compact)
-      unsupported();
-    if (method === "review/start" && !this.capabilities.review)
-      unsupported();
-    if (method === "turn/start") {
-      const start = params;
-      if (start.outputSchema !== undefined && !this.capabilities.turn?.outputSchema)
-        unsupported();
-      const modalities = this.capabilities.turn?.inputModalities ?? ["text"];
-      if (start.input.some((block) => !modalities.includes(block.type)))
-        unsupported();
-      if (start.overrides && Object.keys(start.overrides).some((key) => !this.capabilities.turn?.overrides?.includes(key)))
-        unsupported();
-    }
-    if (method === "session/config/set") {
-      const patch = params.patch;
-      for (const [key, value] of Object.entries(patch)) {
-        const option = this.capabilities.config?.options.find((option) => option.id === key && option.scope === "session");
-        if (!option)
-          unsupported();
-        if (option && !validateJsonSchema(option.schema, value))
-          throw new HarnessSdkError("INVALID_PARAMS", "Config value does not match schema");
-      }
-    }
-  }
-  call(method, params, options = {}) {
-    if (options.signal?.aborted)
-      return Promise.reject(new HarnessSdkError("REQUEST_ABORTED"));
-    try {
-      this.guard(method, params);
-    } catch (cause) {
-      return Promise.reject(cause);
-    }
-    const key = JSON.stringify([method, params.requestId]);
-    const fingerprint = JSON.stringify(params);
-    const previous = this.requests.get(key);
-    if (previous)
-      return previous.fingerprint === fingerprint ? previous.result : Promise.reject(new HarnessSdkError("REQUEST_ID_CONFLICT"));
-    const cacheLimit = this.options.requestCacheSize ?? 1024;
-    if (this.requests.size >= cacheLimit) {
-      for (const [id, entry] of this.requests)
-        if (entry.settled) {
-          this.requests.delete(id);
-          break;
-        }
-      if (this.requests.size >= cacheLimit)
-        return Promise.reject(new HarnessSdkError("BACKPRESSURE_EXCEEDED", "Request limit exceeded"));
-    }
-    const result = waitForRequest(async () => {
-      const backend = this.requireBackend(method);
-      if (method === "interaction/respond") {
-        const answer = params;
-        return await this.interactions.respond(answer.interactionId, answer.requestId, answer.response);
-      }
-      if (method === "interaction/cancel") {
-        const cancel = params;
-        return await this.interactions.cancel(cancel.interactionId, cancel.reason);
-      }
-      const execution = method === "turn/start" || method === "review/start";
-      const exclusive = execution || method === "session/config/set" || method === "session/revert" || method === "session/close" || method === "compact/start" || method === "goal/set" || method === "goal/clear";
-      if (exclusive && (this.activeTurnId || this.controlBusy || this.maintenancePending))
-        throw new HarnessSdkError("SESSION_BUSY");
-      if (method === "turn/steer" && this.activeTurnId !== params.expectedTurnId)
-        throw new HarnessSdkError("TURN_MISMATCH");
-      if (method === "turn/interrupt" && this.activeTurnId !== params.turnId)
-        throw new HarnessSdkError("TURN_MISMATCH");
-      if (exclusive)
-        this.controlBusy = true;
-      if (method === "compact/start") {
-        this.maintenancePending = true;
-        this.state.status = "running";
-        await this.emit({ type: "session/state", payload: this.snapshot });
-      }
-      const turnId = execution ? params.turnId : undefined;
-      if (turnId) {
-        if (this.started.has(turnId) || this.ended.has(turnId)) {
-          this.controlBusy = false;
-          throw new HarnessSdkError("TURN_ID_CONFLICT");
-        }
-        this.activeTurnId = turnId;
-      }
-      try {
-        let value = await backend.execute(method, params);
-        assertResult(method, value);
-        value = this.secrets.result(method, value);
-        assertResult(method, value);
-        if (method === "compact/start" && value.status === "accepted" && !this.maintenancePending)
-          value = { ...value, status: "completed" };
-        if (method === "compact/start" && value.status === "completed") {
-          this.maintenancePending = false;
-          this.state.status = "ready";
-          await this.emit({ type: "session/state", payload: this.snapshot });
-        }
-        if (method === "session/config/set")
-          this.state = structuredClone(value);
-        if (method === "session/revert") {
-          const nativeRef = value.nativeRef;
-          if (nativeRef) {
-            this._binding = immutable({ ...this.binding, nativeRef });
-            this.state.binding = structuredClone(this.binding);
-          }
-        }
-        if (method === "history/read") {
-          let page = this.secrets.history(value);
-          if (this.options.redactHistory)
-            page = await this.options.redactHistory(this.binding, page);
-          assertResult("history/read", page);
-          return page;
-        }
-        return value;
-      } catch (cause) {
-        if (method === "compact/start" && !sdkError(cause).outcomeUnknown) {
-          this.maintenancePending = false;
-          this.state.status = "ready";
-          await this.emit({ type: "session/state", payload: this.snapshot }).catch(() => {});
-        }
-        if (turnId && this.started.has(turnId) && !this.ended.has(turnId))
-          await this.fail(cause);
-        else if (turnId && this.activeTurnId === turnId)
-          this.activeTurnId = undefined;
-        throw cause;
-      } finally {
-        if (exclusive)
-          this.controlBusy = false;
-      }
-    }, options, this.options.requestTimeoutMs).catch((cause) => {
-      if (sdkError(cause).outcomeUnknown) {
-        this.recovering = true;
-        this.state.status = "recoveryRequired";
-      }
-      throw cause;
-    });
-    this.requests.set(key, { fingerprint, result, settled: false });
-    result.finally(() => {
-      const entry = this.requests.get(key);
-      if (entry)
-        entry.settled = true;
-    }).catch(() => {});
-    return result;
-  }
-  startTurn(params, options) {
-    return this.call("turn/start", params, options);
-  }
-  steer(params, options) {
-    return this.call("turn/steer", params, options);
-  }
-  interrupt(params, options) {
-    return this.call("turn/interrupt", params, options);
-  }
-  respond(params, options) {
-    return this.call("interaction/respond", params, options);
-  }
-  cancelInteraction(params, options) {
-    return this.call("interaction/cancel", params, options);
-  }
-  setConfig(params, options) {
-    return this.call("session/config/set", params, options);
-  }
-  revert(params, options) {
-    return this.call("session/revert", params, options);
-  }
-  readHistory(params, options) {
-    return this.call("history/read", params, options);
-  }
-  setGoal(params, options) {
-    return this.call("goal/set", params, options);
-  }
-  clearGoal(params, options) {
-    return this.call("goal/clear", params, options);
-  }
-  compact(params, options) {
-    return this.call("compact/start", params, options);
-  }
-  review(params, options) {
-    return this.call("review/start", params, options);
-  }
-  async close(options) {
-    if (this.closed && !this.recovering)
-      return;
-    await this.call("session/close", { requestId: this.createId(), sessionId: this.binding.sessionId }, options);
-    this.closed = true;
-    this.state.status = "closed";
-    await this.disposeBackend();
-    this.queue.end();
-  }
-  disposeBackend() {
-    return this.backendDisposal ??= this.backend?.dispose() ?? Promise.resolve();
-  }
-  dispose() {
-    return this.disposePromise ??= (async () => {
-      this.emergencyPublication = true;
-      if (!this.closed)
-        await this.interactions.cancelAll("runtime_disposed");
-      if (this.activeTurnId && this.started.has(this.activeTurnId) && !this.ended.has(this.activeTurnId))
-        await this.fail(new HarnessSdkError("RUNTIME_DISPOSED", "Runtime disposed", false, true));
-      this.closed = true;
-      this.queue.end();
-      await this.disposeBackend();
-    })();
-  }
-}
-
-class ManagedHarnessRuntime {
-  adapter;
-  options;
-  initialized;
-  sessions = new Map;
-  closed = false;
-  disposing;
-  initialization;
-  clientCapabilities;
-  constructor(adapter, options = {}) {
-    this.adapter = adapter;
-    this.options = options;
-  }
-  initialize(params, options) {
-    if (this.closed)
-      return Promise.reject(new HarnessSdkError("RUNTIME_DISPOSED"));
-    assertRequest("initialize", params);
-    negotiateVersion(params.protocolVersions);
-    return this.initialization ??= waitForRequest(async () => {
-      const result = await this.adapter.initialize(params);
-      assertResult("initialize", result);
-      if (!params.protocolVersions.includes(result.protocolVersion))
-        throw new HarnessSdkError("PROTOCOL_VERSION_UNSUPPORTED");
-      this.initialized = immutable(result);
-      this.clientCapabilities = immutable(params.clientCapabilities ?? {});
-      return this.initialized;
-    }, options, this.options.requestTimeoutMs).catch((cause) => {
-      this.initialization = undefined;
-      throw cause;
-    });
-  }
-  async openSession(params, options) {
-    if (options?.signal?.aborted)
-      throw new HarnessSdkError("REQUEST_ABORTED");
-    assertRequest("session/open", params);
-    if (this.closed)
-      throw new HarnessSdkError("RUNTIME_DISPOSED");
-    if (!this.initialized)
-      throw new HarnessSdkError("NOT_INITIALIZED");
-    const previous = this.sessions.get(params.binding.sessionId);
-    if (previous && !previous.isClosed)
-      throw new HarnessSdkError("SESSION_ALREADY_OPEN");
-    if (params.mode === "resume" && !this.initialized.capabilities.session?.resume)
-      throw new HarnessSdkError("CAPABILITY_UNSUPPORTED");
-    if (params.mode === "fork" && (!params.fork || !this.initialized.capabilities.session?.fork?.includes(params.fork.boundary.relation)))
-      throw new HarnessSdkError("CAPABILITY_UNSUPPORTED");
-    const source = params.mode === "fork" && params.fork ? this.sessions.get(params.fork.sourceSessionId) : undefined;
-    const releaseSource = source && !source.isClosed ? source.reserveFork(params.binding) : undefined;
-    try {
-      const session = new ManagedHarnessSession(params.binding, this.initialized.capabilities, this.options, params, this.clientCapabilities);
-      this.sessions.set(params.binding.sessionId, session);
-      try {
-        await waitForRequest(async () => {
-          const backend = await this.adapter.openSession(params, session);
-          await session.attach(backend);
-        }, options, this.options.openTimeoutMs ?? 120000);
-        return session;
-      } catch (cause) {
-        await session.dispose();
-        this.sessions.delete(params.binding.sessionId);
-        throw cause;
-      }
-    } finally {
-      releaseSource?.();
-    }
-  }
-  dispose() {
-    return this.disposing ??= (async () => {
-      this.closed = true;
-      const results = await Promise.allSettled([...this.sessions.values()].map((session) => session.dispose()));
-      const [adapterResult] = await Promise.allSettled([this.adapter.dispose()]);
-      this.sessions.clear();
-      const failure = [...results, adapterResult].find((result) => result.status === "rejected");
-      if (failure?.status === "rejected")
-        throw failure.reason;
-    })();
-  }
-}
-function createHarnessRuntime(adapter, options) {
-  return new ManagedHarnessRuntime(adapter, options);
-}
-// packages/core/src/identity.ts
-class NativeIdentityMap {
-  createId;
-  turns = new Map;
-  reverseTurns = new Map;
-  items = new Map;
-  constructor(createId) {
-    this.createId = createId;
-  }
-  bindTurn(turnId, nativeTurnId) {
-    const previous = this.turns.get(nativeTurnId);
-    const reverse = this.reverseTurns.get(turnId);
-    if (previous && previous !== turnId || reverse && reverse !== nativeTurnId)
-      throw new HarnessSdkError("PROTOCOL_ERROR", "Conflicting native turn identity");
-    this.turns.set(nativeTurnId, turnId);
-    this.reverseTurns.set(turnId, nativeTurnId);
-  }
-  turn(nativeTurnId) {
-    return this.turns.get(nativeTurnId);
-  }
-  nativeTurn(turnId) {
-    return this.reverseTurns.get(turnId);
-  }
-  item(turnId, nativeItemId) {
-    const key = JSON.stringify([turnId, nativeItemId]);
-    let value = this.items.get(key);
-    if (!value) {
-      value = this.createId();
-      this.items.set(key, value);
-    }
-    return value;
-  }
-  clear() {
-    this.turns.clear();
-    this.reverseTurns.clear();
-    this.items.clear();
-  }
-}
-// packages/core/src/process.ts
-import { spawn } from "node:child_process";
-import { setTimeout as delay } from "node:timers/promises";
-
-class ProcessPortError extends Error {
-  code;
-  nativeCode;
-  constructor(code, message, options) {
-    super(message);
-    this.name = "ProcessPortError";
-    this.code = code;
-    const cause = options?.cause;
-    if (cause && typeof cause === "object" && "code" in cause && typeof cause.code === "string" && /^[A-Z][A-Z0-9_]{0,63}$/.test(cause.code))
-      this.nativeCode = cause.code;
-  }
-}
-function exists(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
-function signalGroup(pid, signal) {
-  try {
-    process.kill(-pid, signal);
-  } catch (error) {
-    if (error.code !== "ESRCH")
-      throw error;
-  }
-}
-async function signalGroupWithExitRace(pid, signal) {
-  for (let attempt = 0;; attempt++) {
-    try {
-      signalGroup(pid, signal);
-      return;
-    } catch (error) {
-      if (error.code !== "EPERM" || attempt >= 4)
-        throw error;
-      await delay(10);
-    }
-  }
-}
-async function windowsKillTree(pid, force) {
-  await new Promise((resolve, reject) => {
-    const killer = spawn("taskkill.exe", ["/PID", String(pid), "/T", ...force ? ["/F"] : []], {
-      stdio: "ignore",
-      windowsHide: true,
-      shell: false
-    });
-    killer.once("error", reject);
-    killer.once("exit", (code) => {
-      if (code === 0 || !exists(pid))
-        resolve();
-      else
-        reject(new ProcessPortError("PROCESS_DISPOSE_FAILED", "Unable to terminate harness process tree"));
-    });
-  });
-}
-async function terminateTree(child, pid, timeoutMs, didExit) {
-  if (!Number.isSafeInteger(pid) || pid <= 1)
-    throw new ProcessPortError("PROCESS_DISPOSE_FAILED", "Invalid original harness PID");
-  if (process.platform === "win32") {
-    if (!didExit()) {
-      try {
-        await windowsKillTree(pid, false);
-      } catch {
-        if (!didExit())
-          await windowsKillTree(pid, true);
-      }
-    }
-    const deadline = Date.now() + timeoutMs;
-    while (!didExit() && Date.now() < deadline)
-      await delay(10);
-    if (!didExit())
-      await windowsKillTree(pid, true);
-    return;
-  }
-  await signalGroupWithExitRace(pid, "SIGTERM");
-  const deadline = Date.now() + timeoutMs;
-  while (exists(-pid) && Date.now() < deadline)
-    await delay(10);
-  if (exists(-pid))
-    await signalGroupWithExitRace(pid, "SIGKILL");
-}
-async function spawnHarnessProcess(options) {
-  if (!options.command || options.command.includes("\x00") || options.args?.some((arg) => arg.includes("\x00"))) {
-    throw new ProcessPortError("HARNESS_UNAVAILABLE", "Invalid harness executable or argument");
-  }
-  const timeoutMs = options.shutdownTimeoutMs ?? 1000;
-  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 60000) {
-    throw new ProcessPortError("HARNESS_UNAVAILABLE", "Invalid process shutdown timeout");
-  }
-  const owned = options.owned ?? true;
-  let child;
-  try {
-    child = spawn(options.command, [...options.args ?? []], {
-      cwd: options.cwd,
-      env: options.env,
-      stdio: ["pipe", "pipe", "pipe"],
-      detached: owned && process.platform !== "win32",
-      shell: false,
-      windowsHide: true
-    });
-  } catch (cause) {
-    throw new ProcessPortError("HARNESS_UNAVAILABLE", "Unable to start harness executable", { cause });
-  }
-  let didExit = false;
-  let originalPid = child.pid;
-  let disposePromise;
-  const exited = new Promise((resolve) => {
-    child.once("exit", (code, signal) => {
-      didExit = true;
-      resolve({ code, signal });
-    });
-    child.once("error", (error) => {
-      if (!child.pid) {
-        didExit = true;
-        resolve({ code: null, signal: null, errorCode: error.code });
-      }
-    });
-  });
-  child.stdin.on("error", () => {});
-  try {
-    await new Promise((resolve, reject) => {
-      child.once("spawn", () => {
-        if (child.pid !== undefined && child.pid > 1)
-          originalPid = child.pid;
-        resolve();
-      });
-      child.once("error", reject);
-    });
-  } catch (cause) {
-    child.stdin.destroy();
-    child.stdout.destroy();
-    child.stderr.destroy();
-    throw new ProcessPortError("HARNESS_UNAVAILABLE", "Unable to start harness executable", { cause });
-  }
-  const pid = originalPid;
-  const closeInput = () => new Promise((resolve, reject) => {
-    if (child.stdin.destroyed || child.stdin.writableEnded) {
-      resolve();
-      return;
-    }
-    child.stdin.end((error) => error ? reject(new ProcessPortError("PROCESS_WRITE_FAILED", "Unable to close harness input", { cause: error })) : resolve());
-  });
-  return {
-    pid,
-    owned,
-    stdout: child.stdout,
-    stderr: child.stderr,
-    exited,
-    write(chunk) {
-      if (disposePromise || child.stdin.destroyed || child.stdin.writableEnded || didExit) {
-        return Promise.reject(new ProcessPortError("PROCESS_WRITE_FAILED", "Harness process input is closed"));
-      }
-      return new Promise((resolve, reject) => {
-        child.stdin.write(chunk, (error) => error ? reject(new ProcessPortError("PROCESS_WRITE_FAILED", "Unable to write harness input", { cause: error })) : resolve());
-      });
-    },
-    closeInput,
-    dispose() {
-      return disposePromise ??= (async () => {
-        try {
-          if (owned) {
-            await terminateTree(child, pid, timeoutMs, () => didExit);
-            if (!didExit) {
-              await Promise.race([exited, delay(1000)]);
-              if (!didExit)
-                throw new ProcessPortError("PROCESS_DISPOSE_FAILED", "Harness process did not exit after termination");
-            }
-          } else
-            child.unref();
-        } catch (cause) {
-          if (cause instanceof ProcessPortError)
-            throw cause;
-          throw new ProcessPortError("PROCESS_DISPOSE_FAILED", "Unable to dispose harness process", { cause });
-        } finally {
-          child.stdin.destroy();
-          child.stdout.destroy();
-          child.stderr.destroy();
-        }
-      })();
-    }
-  };
-}
-export {
-  BoundedEventQueue,
-  HarnessSdkError,
-  InteractionRegistry,
-  ManagedHarnessRuntime,
-  ManagedHarnessSession,
-  NativeIdentityMap,
-  ProcessPortError,
-  SecretRedactor,
-  createHarnessRuntime,
-  sdkError,
-  spawnHarnessProcess,
-  waitForRequest
-};