agents 0.20.0 → 0.21.0

package/dist/chat/transport.d.ts

@@ -0,0 +1,10 @@
+import {
+  n as WebSocketChatTransport,
+  r as WebSocketChatTransportOptions,
+  t as AgentConnection
+} from "../ws-chat-transport-UNRIS2xl.js";
+export {
+  type AgentConnection,
+  WebSocketChatTransport,
+  type WebSocketChatTransportOptions
+};

package/dist/chat/transport.js

@@ -0,0 +1,2 @@
+import { t as WebSocketChatTransport } from "../ws-chat-transport-CIoOBbO7.js";
+export { WebSocketChatTransport };

package/dist/chat-sdk/index.d.ts

@@ -2,7 +2,7 @@ import {
   O as Agent,
   ct as SubAgentClass,
   lt as SubAgentStub
-} from "../agent-tool-types-Btk9ETS-.js";
+} from "../agent-tool-types-CzGGB-20.js";
 import { Lock, QueueEntry, StateAdapter } from "chat";
 
 //#region src/chat-sdk/agent.d.ts

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { O as Agent } from "./agent-tool-types-Btk9ETS-.js";
+import { O as Agent } from "./agent-tool-types-CzGGB-20.js";
 import {
   ClientParameters,
   Method,

package/dist/cloudflare-BduZwmYK.js

@@ -0,0 +1,204 @@
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as cloudflareWorkers from "cloudflare:workers";
+//#region src/observability/tracing/tracer.ts
+/**
+* Spans that asked to be invocation-bounded while a scope was active. Closed
+* when that scope ends; see {@link withInvocationScope}.
+*/
+const invocationScope = new AsyncLocalStorage();
+/**
+* Runs `body` as one traced invocation.
+*
+* Work that escapes its native invocation cannot be traced from the context it
+* started in: the still-open span is force-closed against the invocation that
+* owned that context, which reports a negative duration or `span_not_ended`.
+* Spans opened with {@link SpanLifetime.boundToInvocation} inside this scope
+* are therefore closed before `body` settles — but not one moment earlier, so
+* everything that completes during the invocation (the normal case: a chat
+* turn is awaited by the handler that received it) still records its finish
+* attributes. A span truncated this way is marked
+* `cloudflare.agents.span.truncated` rather than passing as complete.
+*/
+function withInvocationScope(body, options) {
+	const current = invocationScope.getStore();
+	if (options?.detached !== true && current !== void 0 && !current.ended) return body();
+	const scope = {
+		ended: false,
+		open: /* @__PURE__ */ new Set()
+	};
+	const endInvocation = () => {
+		scope.ended = true;
+		for (const span of scope.open) try {
+			span.truncate();
+		} catch {}
+		scope.open.clear();
+	};
+	return invocationScope.run(scope, () => {
+		let result;
+		try {
+			result = body();
+		} catch (cause) {
+			endInvocation();
+			throw cause;
+		}
+		if (isPromiseLike(result)) return Promise.resolve(result).finally(endInvocation);
+		endInvocation();
+		return result;
+	});
+}
+/** Creates a tracer from a runtime span capability. */
+function createTracer(runtime) {
+	return new RuntimeTracer(runtime);
+}
+var RuntimeTracer = class {
+	constructor(runtime) {
+		this.runtime = runtime;
+	}
+	withSpan(name, attributes, run, lifetime) {
+		return this.activate(name, attributes, (span) => {
+			const outOfBand = lifetime?.boundToInvocation === true && bindToInvocation(span);
+			const result = run(span);
+			if (isPromiseLike(result)) {
+				if (outOfBand) span.truncate();
+				return Promise.resolve(result).catch((cause) => {
+					span.fail(cause);
+					throw cause;
+				}).finally(() => {
+					span.close();
+				});
+			}
+			if (outOfBand) span.truncate();
+			span.close();
+			return result;
+		});
+	}
+	openSpan(name, attributes, activate, lifetime) {
+		if (!lifetime?.boundToInvocation) return this.activate(name, attributes, activate);
+		return this.activate(name, attributes, (span) => {
+			const invocationEnded = bindToInvocation(span);
+			try {
+				return activate(span);
+			} finally {
+				if (invocationEnded) span.truncate();
+			}
+		});
+	}
+	/**
+	* Shared scaffold: opens an active span, seeds its attributes, and fails the
+	* span on a thrown defect before rethrowing. The `body` decides the span's
+	* finishing policy (managed vs. caller-owned).
+	*/
+	activate(name, attributes, body) {
+		return this.runtime.startActiveSpan(name, (writer) => {
+			setAttributes(writer, attributes);
+			const span = new ManagedSpan(writer);
+			try {
+				return body(span);
+			} catch (cause) {
+				span.fail(cause);
+				throw cause;
+			}
+		});
+	}
+};
+var _closed = /* @__PURE__ */ new WeakMap();
+var ManagedSpan = class {
+	constructor(span) {
+		this.span = span;
+		_classPrivateFieldInitSpec(this, _closed, false);
+	}
+	get isTraced() {
+		return this.span.isTraced;
+	}
+	/** INTERNAL: see {@link writeSpanAttributes}. */
+	writeAttributes(attributes) {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		setAttributes(this.span, attributes);
+	}
+	finish(attributes = {}) {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		setAttributes(this.span, attributes);
+		this.close();
+	}
+	fail(cause) {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		if (isCancellation(cause)) setAttributes(this.span, { "cloudflare.agents.canceled": true });
+		else setAttributes(this.span, { "error.type": cause instanceof Error ? cause.name || "Error" : typeof cause });
+		this.close();
+	}
+	close() {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		_classPrivateFieldSet2(_closed, this, true);
+		this.span.end();
+	}
+	/**
+	* Closes a span whose work has not finished because its invocation is ending.
+	* The marker distinguishes "this span has no tokens because the turn escaped
+	* its invocation" from "this span completed and reported none".
+	*/
+	truncate() {
+		if (_classPrivateFieldGet2(_closed, this)) return;
+		setAttributes(this.span, { "cloudflare.agents.span.truncated": true });
+		this.close();
+	}
+};
+/**
+* Registers a span for closure at the end of the current invocation, and
+* reports whether that invocation has already ended.
+*
+* Outside any scope the span keeps its natural lifetime: with no known
+* invocation boundary there is nothing to bound it to, and closing early would
+* discard finish attributes for no gain. Inside a scope that has already
+* ended — work resumed later while still carrying this context — the span
+* cannot outlive an invocation that is already gone, so the caller truncates
+* it as soon as it has written what it knows.
+*/
+function bindToInvocation(span) {
+	const scope = invocationScope.getStore();
+	if (scope === void 0) return false;
+	if (scope.ended) return true;
+	scope.open.add(span);
+	return false;
+}
+/**
+* INTERNAL: writes attributes onto an open managed span. Lets instrumentation
+* defer expensive attribute computation until after the isTraced check (span
+* names must exist at open time; attributes need not). Not part of the public
+* barrel surface.
+*/
+function writeSpanAttributes(span, attributes) {
+	if (span instanceof ManagedSpan) span.writeAttributes(attributes);
+}
+function setAttributes(span, attributes) {
+	if (!span.isTraced) return;
+	try {
+		for (const [key, value] of Object.entries(attributes)) if (value !== void 0) span.setAttribute(key, value);
+	} catch {}
+}
+function isPromiseLike(value) {
+	return value !== null && value !== void 0 && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+/**
+* Recognizes caller/runtime cancellation (an `AbortError`, e.g. from an aborted
+* `AbortSignal`) so it can be classified separately from genuine failures. A
+* `DOMException` named `AbortError` is not always an `Error` instance, so this
+* probes the `name` field structurally rather than via `instanceof`.
+*/
+function isCancellation(cause) {
+	return typeof cause === "object" && cause !== null && "name" in cause && cause.name === "AbortError";
+}
+//#endregion
+//#region src/observability/tracing/cloudflare.ts
+const noopSpan = {
+	isTraced: false,
+	setAttribute() {},
+	end() {}
+};
+const tracer = createTracer(cloudflareWorkers.tracing ?? { startActiveSpan(_name, run) {
+	return run(noopSpan);
+} });
+//#endregion
+export { withInvocationScope as n, writeSpanAttributes as r, tracer as t };
+
+//# sourceMappingURL=cloudflare-BduZwmYK.js.map

package/dist/cloudflare-BduZwmYK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-BduZwmYK.js","names":[],"sources":["../src/observability/tracing/tracer.ts","../src/observability/tracing/cloudflare.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"node:async_hooks\";\n\n/** Attribute values accepted by custom spans. */\nexport type TraceAttributeValue = string | number | boolean | undefined;\n\n/** Initial or finish attributes attached to a span. */\nexport type TraceAttributes = Readonly<Record<string, TraceAttributeValue>>;\n\n/** A value that may complete synchronously or through a promise-like result. */\nexport type MaybePromise<T> = T | PromiseLike<T>;\n\n/** Minimal runtime span surface used by tracers. */\nexport type SpanWriter = {\n  readonly isTraced: boolean;\n  setAttribute(key: string, value: TraceAttributeValue): void;\n  end(): void;\n};\n\n/** Runtime capability for starting an active span in the current async context. */\nexport type SpanRuntime = {\n  startActiveSpan<T>(name: string, run: (span: SpanWriter) => T): T;\n};\n\n/** Optional automatic lifetime policy for invocation-bounded spans. */\nexport type SpanLifetime = {\n  /**\n   * Close the span no later than the end of the surrounding\n   * {@link withInvocationScope}, so it cannot outlive the native invocation\n   * that owns its tracing context. Ignored outside such a scope.\n   */\n  readonly boundToInvocation?: boolean;\n};\n\n/** AgentTracer seam used by integrations. */\nexport type AgentTracer = {\n  /**\n   * Runs `run` inside an active span whose lifetime the tracer owns: the span\n   * finishes when `run` returns (or its promise resolves) and fails when `run`\n   * throws or rejects. Callers do not call {@link AgentSpan.finish}/{@link AgentSpan.fail};\n   * doing so early is safe but the tracer guarantees closure.\n   *\n   * @template T The value produced by the instrumented work.\n   */\n  withSpan<T>(\n    name: string,\n    attributes: TraceAttributes,\n    run: (span: AgentSpan) => MaybePromise<T>,\n    lifetime?: SpanLifetime\n  ): T | Promise<T>;\n  /**\n   * Activates a span and returns whatever `activate` returns (typically the\n   * {@link AgentSpan} handle itself). The caller owns the span lifetime and MUST call\n   * {@link AgentSpan.finish} or {@link AgentSpan.fail}; an unfinished span leaks. Use this\n   * for work that outlives the callback, such as streams and event-driven\n   * telemetry. A throw from `activate` still fails the span before rethrowing.\n   *\n   * @template T The value returned to the caller, usually the span handle.\n   */\n  openSpan<T>(\n    name: string,\n    attributes: TraceAttributes,\n    activate: (span: AgentSpan) => T,\n    lifetime?: SpanLifetime\n  ): T;\n};\n\n/** Active span handle passed to instrumented work. */\nexport type AgentSpan = {\n  /**\n   * Whether this invocation is actually being traced. Instrumentation can use\n   * this to skip expensive capture work when nobody is listening.\n   */\n  readonly isTraced: boolean;\n  /** Records the optional finish attributes and ends the span. Idempotent. */\n  finish(attributes?: TraceAttributes): void;\n  /**\n   * Ends the span as not-successful. Genuine failures record `error.type`;\n   * recognized cancellations (an `AbortError`) record `canceled` instead so aborts\n   * are not counted as errors. The cause message is never recorded. Idempotent.\n   */\n  fail(cause: unknown): void;\n};\n\ntype InvocationScope = {\n  /** Bounded spans still open. Emptied when the invocation ends. */\n  readonly open: Set<ManagedSpan>;\n  /** Whether the invocation this scope represents has already ended. */\n  ended: boolean;\n};\n\nexport type InvocationScopeOptions = {\n  /**\n   * Open a scope even inside a live one, for work deliberately detached from\n   * the handler that started it — `ctx.waitUntil` bodies, queue drains — which\n   * runs on past that handler and must not be cut off with it.\n   */\n  readonly detached?: boolean;\n};\n\n/**\n * Spans that asked to be invocation-bounded while a scope was active. Closed\n * when that scope ends; see {@link withInvocationScope}.\n */\nconst invocationScope = new AsyncLocalStorage<InvocationScope>();\n\n/**\n * Runs `body` as one traced invocation.\n *\n * Work that escapes its native invocation cannot be traced from the context it\n * started in: the still-open span is force-closed against the invocation that\n * owned that context, which reports a negative duration or `span_not_ended`.\n * Spans opened with {@link SpanLifetime.boundToInvocation} inside this scope\n * are therefore closed before `body` settles — but not one moment earlier, so\n * everything that completes during the invocation (the normal case: a chat\n * turn is awaited by the handler that received it) still records its finish\n * attributes. A span truncated this way is marked\n * `cloudflare.agents.span.truncated` rather than passing as complete.\n */\nexport function withInvocationScope<T>(\n  body: () => T,\n  options?: InvocationScopeOptions\n): T {\n  // Nested scopes would truncate spans at an inner boundary that is not an\n  // invocation edge, so the outermost live scope owns the lifetime. A scope\n  // that has already ended is not an enclosing invocation at all — it is a\n  // leftover context on work that resumed later — so `body` starts a new one.\n  const current = invocationScope.getStore();\n  if (options?.detached !== true && current !== undefined && !current.ended) {\n    return body();\n  }\n\n  const scope: InvocationScope = { ended: false, open: new Set() };\n  const endInvocation = () => {\n    scope.ended = true;\n    for (const span of scope.open) {\n      // Fail open: this runs on the return path of every agent handler, so a\n      // span writer that throws must not take the handler's result with it,\n      // nor stop the remaining spans from closing.\n      try {\n        span.truncate();\n      } catch {\n        // Nothing useful to do with a broken span writer.\n      }\n    }\n    scope.open.clear();\n  };\n\n  return invocationScope.run(scope, () => {\n    let result: T;\n    try {\n      result = body();\n    } catch (cause: unknown) {\n      endInvocation();\n      throw cause;\n    }\n\n    if (isPromiseLike(result)) {\n      // SAFETY: T is promise-like here, so the settled promise is still a T.\n      return Promise.resolve(result).finally(endInvocation) as T;\n    }\n\n    endInvocation();\n    return result;\n  });\n}\n\n/** Creates a tracer from a runtime span capability. */\nexport function createTracer(runtime: SpanRuntime): AgentTracer {\n  return new RuntimeTracer(runtime);\n}\n\nclass RuntimeTracer implements AgentTracer {\n  constructor(private readonly runtime: SpanRuntime) {}\n\n  withSpan<T>(\n    name: string,\n    attributes: TraceAttributes,\n    run: (span: AgentSpan) => MaybePromise<T>,\n    lifetime?: SpanLifetime\n  ): T | Promise<T> {\n    return this.activate(name, attributes, (span) => {\n      // Ask before running: a span that opens and closes in one tick still\n      // needs to know whether that tick happened after its invocation ended.\n      const outOfBand =\n        lifetime?.boundToInvocation === true && bindToInvocation(span);\n      const result = run(span);\n      if (isPromiseLike(result)) {\n        if (outOfBand) {\n          span.truncate();\n        }\n        return Promise.resolve(result)\n          .catch((cause: unknown) => {\n            span.fail(cause);\n            throw cause;\n          })\n          .finally(() => {\n            span.close();\n          });\n      }\n\n      if (outOfBand) {\n        span.truncate();\n      }\n      span.close();\n      return result;\n    });\n  }\n\n  openSpan<T>(\n    name: string,\n    attributes: TraceAttributes,\n    activate: (span: AgentSpan) => T,\n    lifetime?: SpanLifetime\n  ): T {\n    if (!lifetime?.boundToInvocation) {\n      return this.activate(name, attributes, activate);\n    }\n\n    return this.activate(name, attributes, (span) => {\n      const invocationEnded = bindToInvocation(span);\n      try {\n        return activate(span);\n      } finally {\n        // Truncate only once `activate` has had its turn: callers that open\n        // with an empty attribute set and write the real one lazily (the AI\n        // operation span does, to stay cheap for untraced calls) would\n        // otherwise be closed before writing anything at all.\n        if (invocationEnded) {\n          span.truncate();\n        }\n      }\n    });\n  }\n\n  /**\n   * Shared scaffold: opens an active span, seeds its attributes, and fails the\n   * span on a thrown defect before rethrowing. The `body` decides the span's\n   * finishing policy (managed vs. caller-owned).\n   */\n  private activate<T>(\n    name: string,\n    attributes: TraceAttributes,\n    body: (span: ManagedSpan) => T\n  ): T {\n    return this.runtime.startActiveSpan(name, (writer) => {\n      setAttributes(writer, attributes);\n      const span = new ManagedSpan(writer);\n\n      try {\n        return body(span);\n      } catch (cause: unknown) {\n        span.fail(cause);\n        throw cause;\n      }\n    });\n  }\n}\n\nclass ManagedSpan implements AgentSpan {\n  #closed = false;\n\n  constructor(private readonly span: SpanWriter) {}\n\n  get isTraced(): boolean {\n    return this.span.isTraced;\n  }\n\n  /** INTERNAL: see {@link writeSpanAttributes}. */\n  writeAttributes(attributes: TraceAttributes): void {\n    if (this.#closed) {\n      return;\n    }\n\n    setAttributes(this.span, attributes);\n  }\n\n  finish(attributes: TraceAttributes = {}): void {\n    if (this.#closed) {\n      return;\n    }\n\n    setAttributes(this.span, attributes);\n    this.close();\n  }\n\n  fail(cause: unknown): void {\n    if (this.#closed) {\n      return;\n    }\n\n    if (isCancellation(cause)) {\n      // Cancellation is a control path, not a failure: OTel semconv leaves\n      // status Unset and records no error.type for cancellations, so aborted\n      // operations do not inflate error rates. The vendor marker is additive.\n      setAttributes(this.span, { \"cloudflare.agents.canceled\": true });\n    } else {\n      // Workers' custom Span API does not currently expose setStatus(). Do not\n      // invent an `otel.status_code` attribute: status is span state in OTel,\n      // not an attribute. error.type remains the standard queryable marker.\n      setAttributes(this.span, {\n        \"error.type\":\n          cause instanceof Error ? cause.name || \"Error\" : typeof cause\n      });\n    }\n\n    this.close();\n  }\n\n  close(): void {\n    if (this.#closed) {\n      return;\n    }\n\n    this.#closed = true;\n    this.span.end();\n  }\n\n  /**\n   * Closes a span whose work has not finished because its invocation is ending.\n   * The marker distinguishes \"this span has no tokens because the turn escaped\n   * its invocation\" from \"this span completed and reported none\".\n   */\n  truncate(): void {\n    if (this.#closed) {\n      return;\n    }\n\n    setAttributes(this.span, { \"cloudflare.agents.span.truncated\": true });\n    this.close();\n  }\n}\n\n/**\n * Registers a span for closure at the end of the current invocation, and\n * reports whether that invocation has already ended.\n *\n * Outside any scope the span keeps its natural lifetime: with no known\n * invocation boundary there is nothing to bound it to, and closing early would\n * discard finish attributes for no gain. Inside a scope that has already\n * ended — work resumed later while still carrying this context — the span\n * cannot outlive an invocation that is already gone, so the caller truncates\n * it as soon as it has written what it knows.\n */\nfunction bindToInvocation(span: ManagedSpan): boolean {\n  const scope = invocationScope.getStore();\n  if (scope === undefined) {\n    return false;\n  }\n\n  if (scope.ended) {\n    return true;\n  }\n\n  scope.open.add(span);\n  return false;\n}\n\n/**\n * INTERNAL: writes attributes onto an open managed span. Lets instrumentation\n * defer expensive attribute computation until after the isTraced check (span\n * names must exist at open time; attributes need not). Not part of the public\n * barrel surface.\n */\nexport function writeSpanAttributes(\n  span: AgentSpan,\n  attributes: TraceAttributes\n): void {\n  if (span instanceof ManagedSpan) {\n    span.writeAttributes(attributes);\n  }\n}\n\nfunction setAttributes(span: SpanWriter, attributes: TraceAttributes): void {\n  if (!span.isTraced) {\n    return;\n  }\n\n  // Fail-safe: a throwing writer must not leak the span or replace the\n  // application's original error with a telemetry one.\n  try {\n    for (const [key, value] of Object.entries(attributes)) {\n      if (value !== undefined) {\n        span.setAttribute(key, value);\n      }\n    }\n  } catch {\n    // Drop the attributes; the span still closes.\n  }\n}\n\nfunction isPromiseLike<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return (\n    value !== null &&\n    value !== undefined &&\n    (typeof value === \"object\" || typeof value === \"function\") &&\n    \"then\" in value &&\n    typeof value.then === \"function\"\n  );\n}\n\n/**\n * Recognizes caller/runtime cancellation (an `AbortError`, e.g. from an aborted\n * `AbortSignal`) so it can be classified separately from genuine failures. A\n * `DOMException` named `AbortError` is not always an `Error` instance, so this\n * probes the `name` field structurally rather than via `instanceof`.\n */\nfunction isCancellation(cause: unknown): boolean {\n  return (\n    typeof cause === \"object\" &&\n    cause !== null &&\n    \"name\" in cause &&\n    cause.name === \"AbortError\"\n  );\n}\n","import * as cloudflareWorkers from \"cloudflare:workers\";\nimport { createTracer } from \"./tracer\";\nimport type { SpanRuntime, SpanWriter, AgentTracer } from \"./tracer\";\n\nconst noopSpan: SpanWriter = {\n  isTraced: false,\n  setAttribute() {},\n  end() {}\n};\n\nconst noopRuntime: SpanRuntime = {\n  startActiveSpan(_name, run) {\n    return run(noopSpan);\n  }\n};\n\n// Accessed via the namespace so runtimes that predate the `tracing` export\n// degrade to a no-op tracer instead of failing at module-link time — this\n// module loads with the main `agents` entry, not just for tracing users.\nconst runtime: SpanRuntime =\n  (cloudflareWorkers as { tracing?: SpanRuntime }).tracing ?? noopRuntime;\n\nexport const tracer: AgentTracer = createTracer(runtime);\n"],"mappings":"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"}

package/dist/{connector-v2M1zlZp.d.ts → connector-CkQD4MK3.d.ts}

@@ -1,5 +1,6 @@
 import {
   CodemodeConnector,
+  ConnectorTool,
   ConnectorTools,
   ExecutionEndStatus,
   PassEndStatus
@@ -95,6 +96,11 @@ interface ConnectBrowserOptions {
    * {@link getBrowserRecording}.
    */
   recording?: boolean;
+  /**
+   * Select the browser engine. Defaults to Chromium. Use `"kitesurf"` for
+   * Cloudflare's connection-scoped, agent-first browser engine.
+   */
+  browser?: "kitesurf";
 }
 /** An rrweb session recording for a closed Browser Run session. */
 interface BrowserRecording {
@@ -228,7 +234,7 @@ type QuickActionExtractInput = QuickActionPage & {
   /** Natural-language instruction for what to extract. */ prompt?: string /** A JSON Schema describing the desired output shape. */;
   response_format?: {
     type: "json_schema";
-    schema: unknown;
+    json_schema: unknown;
   } /** Bring-your-own model(s), tried in order, for extraction. */;
   custom_ai?: {
     model: string;
@@ -432,6 +438,12 @@ interface BrowserConnectorSessionOptions {
    * {@link BrowserConnector.liveView}/`sessionInfo()`.
    */
   recording?: boolean;
+  /**
+   * Select the browser engine. Defaults to Chromium. Kitesurf is scoped to
+   * one CDP WebSocket, so it supports only one-shot execution without
+   * pause/resume, Live View, recording, or keep-alive.
+   */
+  browser?: "kitesurf";
 }
 type BrowserConnectorOptions = (
   | {
@@ -554,13 +566,14 @@ declare class BrowserConnector extends CodemodeConnector {
   );
   name(): string;
   protected instructions(): string;
+  protected tool(name: string, tool: ConnectorTool): ConnectorTool;
   protected tools(): ConnectorTools;
   /**
    * A pass is over (completed, errored, or paused awaiting approval) — drop
    * the CDP socket. The Browser Run session itself stays alive; a resume
    * reconnects from the durably stored session id.
    */
-  onPassEnd(executionId: string, _status: PassEndStatus): Promise<void>;
+  onPassEnd(executionId: string, status: PassEndStatus): Promise<void>;
   /**
    * The execution is terminal — delete its Browser Run session unless it was
    * promoted to the shared slot via `cdp.startSession()`.
@@ -597,6 +610,10 @@ declare class BrowserConnector extends CodemodeConnector {
    * deleted, so a later resume fails with a clear "session expired" error
    * instead of silently continuing in a fresh browser; tombstones are
    * deleted once they age past the threshold again.
+   *
+   * Kitesurf entries are reclaimed the same way, minus the Browser Run
+   * delete: their stored id is a synthetic per-execution marker, not a
+   * session, and the connection died with the execution.
    */
   sweep(
     options?: BrowserConnectorSweepOptions
@@ -656,4 +673,4 @@ export {
   QuickActionCommonOptions as y,
   BrowserSessionInfo as z
 };
-//# sourceMappingURL=connector-v2M1zlZp.d.ts.map
+//# sourceMappingURL=connector-CkQD4MK3.d.ts.map