@theokit/agents 7.3.1 → 7.4.1

package/dist/{chunk-CVDPGEJF.js → chunk-FJA4QQLZ.js}

@@ -1,31 +1,26 @@
-import {
-  __name
-} from "./chunk-Z4QWC7IK.js";
-
 // src/client/consume-ui-message-stream.ts
 import { parseWireStream, readMessageStream } from "@theokit/presenter/wire";
 async function consumeUIMessageStream(response, onMessage) {
   const chunkStream = await responseToChunkStream(response);
   await consumeChunkStream(chunkStream, onMessage);
 }
-__name(consumeUIMessageStream, "consumeUIMessageStream");
 function responseToChunkStream(response) {
   if (response.body === null) {
-    return Promise.resolve(new ReadableStream({
-      start(controller) {
-        controller.close();
-      }
-    }));
+    return Promise.resolve(
+      new ReadableStream({
+        start(controller) {
+          controller.close();
+        }
+      })
+    );
   }
   return Promise.resolve(parseWireStream(response.body));
 }
-__name(responseToChunkStream, "responseToChunkStream");
 async function consumeChunkStream(stream, onMessage) {
   for await (const message of readMessageStream(stream)) {
     onMessage(message);
   }
 }
-__name(consumeChunkStream, "consumeChunkStream");
 
 // src/client/http-transport.ts
 function toRecord(headers) {
@@ -33,11 +28,7 @@ function toRecord(headers) {
   if (headers instanceof Headers) return Object.fromEntries(headers.entries());
   return headers;
 }
-__name(toRecord, "toRecord");
 var HttpTransport = class {
-  static {
-    __name(this, "HttpTransport");
-  }
   #api;
   #headers;
   #fetch;
@@ -68,15 +59,13 @@ var HttpTransport = class {
       // conversation (SDK history + session-scoped tools like `todolist`) persists across turns instead of
       // resetting on a fresh random session each request. Placed last so a session is never shadowed by an
       // `id` field inside the typed input. Undefined chatId ⇒ key omitted ⇒ server falls back (unchanged).
-      body: JSON.stringify({
-        ...extra,
-        messages,
-        id: chatId
-      }),
+      body: JSON.stringify({ ...extra, messages, id: chatId }),
       signal: abortSignal
     });
     if (!response.ok) {
-      throw new Error(`Agent request to ${this.#api} failed: ${response.status} ${response.statusText}`);
+      throw new Error(
+        `Agent request to ${this.#api} failed: ${response.status} ${response.statusText}`
+      );
     }
     this.#lastRunId = response.headers.get("x-theokit-run-id") ?? void 0;
     return responseToChunkStream(response);
@@ -85,14 +74,13 @@ var HttpTransport = class {
     if (this.#lastRunId === void 0) return null;
     const response = await this.#fetch(`${this.#api}/runs/${this.#lastRunId}/stream`, {
       method: "GET",
-      headers: {
-        ...this.#resolveHeaders(),
-        ...toRecord(options.headers)
-      }
+      headers: { ...this.#resolveHeaders(), ...toRecord(options.headers) }
     });
     if (response.status === 404) return null;
     if (!response.ok) {
-      throw new Error(`Agent reconnect to run ${this.#lastRunId} failed: ${response.status} ${response.statusText}`);
+      throw new Error(
+        `Agent reconnect to run ${this.#lastRunId} failed: ${response.status} ${response.statusText}`
+      );
     }
     return responseToChunkStream(response);
   }
@@ -122,7 +110,6 @@ function extractLastUserText(messages) {
   }
   return "";
 }
-__name(extractLastUserText, "extractLastUserText");
 
 // src/client/in-process-transport.ts
 function generatorToStream(gen) {
@@ -144,101 +131,93 @@ function generatorToStream(gen) {
     }
   });
 }
-__name(generatorToStream, "generatorToStream");
 var ApprovalAbortedError = class extends Error {
-  static {
-    __name(this, "ApprovalAbortedError");
-  }
-  approvalId;
-  constructor(approvalId, motivo) {
-    super(`Aprova\xE7\xE3o '${approvalId}' descartada: ${motivo}.`), this.approvalId = approvalId;
+  constructor(approvalId, reason) {
+    super(`Approval '${approvalId}' discarded: ${reason}.`);
+    this.approvalId = approvalId;
     this.name = "ApprovalAbortedError";
   }
+  approvalId;
 };
 var InProcessTransport = class {
-  static {
-    __name(this, "InProcessTransport");
-  }
   #run;
   /**
-  * Aprovações inline estacionadas: `approvalId` → como resolver **ou rejeitar** a promessa parada.
-  *
-  * M92 — o `reject` entrou junto com a eviction. Antes havia só o `resolve`, e nada apagava a entrada
-  * quando o turno abortava: a promessa ficava pendente **para sempre**, e a chamada de tool do SDK
-  * pendurava com ela. Uma promessa que nunca resolve **nem** rejeita é a forma mais silenciosa de
-  * engolir um erro — nem stack trace existe (`error-handling.md § 2`).
-  */
+   * Parked inline approvals: `approvalId` → how to resolve **or reject** the stalled promise.
+   *
+   * M92 — `reject` arrived together with the eviction. Before there was only `resolve`, and nothing
+   * erased the entry when the turn aborted: the promise stayed pending **forever**, and the SDK tool
+   * call hung with it. A promise that neither resolves **nor** rejects is the quietest way to swallow
+   * an error — not even a stack trace exists (`error-handling.md § 2`).
+   */
   #pending = /* @__PURE__ */ new Map();
-  /** O turno corrente. Um `send()` novo incrementa e varre o anterior. */
-  #turno = 0;
+  /** The current turn. A new `send()` increments it and sweeps the previous one. */
+  #turn = 0;
   constructor(options) {
     this.#run = options.run;
   }
   /**
-  * Cria o `awaitApproval` DESTE turno, com o número e o sinal fechados no closure.
-  *
-  * Campo compartilhado não serve, e a revisão do M92 mediu por quê: um runner do turno 1 que
-  * estaciona **depois** do `send` do turno 2 lê o campo já sobrescrito e nasce etiquetado turno 2 —
-  * o abort do turno 1 não o varre, e a promessa pendura. A primeira correção do M92 trocou "ler no
-  * momento da aprovação" por "ler no `send`", e continuou errada pela mesma razão: um campo só.
-  *
-  * O closure é o único lugar onde o turno de um runner pode viver sem ser sobrescrito por outro.
-  */
-  #criarAwaitApproval(turno, sinal) {
+   * Creates the `awaitApproval` for THIS turn, with the number and the signal closed over.
+   *
+   * A shared field will not do, and the M92 review measured why: a turn-1 runner that parks **after**
+   * turn 2's `send` reads the already-overwritten field and is born labelled turn 2 — turn 1's abort
+   * does not sweep it, and the promise hangs. M92's first fix swapped "read at approval time" for
+   * "read at `send`", and stayed wrong for the same reason: a single field.
+   *
+   * The closure is the only place a runner's turn can live without another one overwriting it.
+   */
+  #createAwaitApproval(turn, signal) {
     return (req) => new Promise((resolve, reject) => {
-      if (sinal?.aborted === true) {
-        reject(new ApprovalAbortedError(req.approvalId, "o turno j\xE1 estava abortado"));
+      if (signal?.aborted === true) {
+        reject(new ApprovalAbortedError(req.approvalId, "the turn was already aborted"));
         return;
       }
       if (this.#pending.has(req.approvalId)) {
-        reject(new Error(`Duplicate pending approval id '${req.approvalId}' \u2014 ids must be unique.`));
+        reject(
+          new Error(`Duplicate pending approval id '${req.approvalId}' \u2014 ids must be unique.`)
+        );
         return;
       }
-      this.#pending.set(req.approvalId, {
-        resolve,
-        reject,
-        turno
-      });
+      this.#pending.set(req.approvalId, { resolve, reject, turn });
     });
   }
   /**
-  * Varre as aprovações de um turno, rejeitando cada uma com erro TIPADO.
-  *
-  * Rejeitar e não `resolve(false)`: um `false` é indistinguível de *"o usuário negou"*, e a diferença
-  * importa — negar é decisão, abortar é interrupção. O SDK precisa das duas para desenrolar a chamada
-  * de tool corretamente.
-  */
-  #varrerTurno(turno, motivo) {
-    for (const [id, entrada] of [
-      ...this.#pending
-    ]) {
-      if (entrada.turno !== turno) continue;
+   * Sweeps a turn's approvals, rejecting each one with a TYPED error.
+   *
+   * Reject rather than `resolve(false)`: a `false` is indistinguishable from *"the user denied"*, and
+   * the difference matters — denying is a decision, aborting is an interruption. The SDK needs both to
+   * unwind the tool call correctly.
+   */
+  #sweepTurn(turn, reason) {
+    for (const [id, entry] of [...this.#pending]) {
+      if (entry.turn !== turn) continue;
       this.#pending.delete(id);
-      entrada.reject(new ApprovalAbortedError(id, motivo));
+      entry.reject(new ApprovalAbortedError(id, reason));
     }
   }
-  /** Quantas aprovações estão estacionadas. Existe para o teste poder provar a eviction. */
-  get pendentes() {
+  /** How many approvals are parked. Exists so the test can prove the eviction. */
+  get pending() {
     return this.#pending.size;
   }
   sendMessages(options) {
     const { messages, abortSignal, metadata } = options;
-    this.#varrerTurno(this.#turno, "um turno novo come\xE7ou");
-    this.#turno += 1;
-    const turnoAtual = this.#turno;
+    this.#sweepTurn(this.#turn, "a new turn started");
+    this.#turn += 1;
+    const currentTurn = this.#turn;
     if (abortSignal?.aborted === true) {
-      this.#varrerTurno(turnoAtual, "o turno j\xE1 estava abortado");
+      this.#sweepTurn(currentTurn, "the turn was already aborted");
     } else {
-      abortSignal?.addEventListener("abort", () => {
-        this.#varrerTurno(turnoAtual, "o turno foi abortado");
-      }, {
-        once: true
-      });
+      abortSignal?.addEventListener(
+        "abort",
+        () => {
+          this.#sweepTurn(currentTurn, "the turn was aborted");
+        },
+        { once: true }
+      );
     }
     const generator = this.#run({
       message: extractLastUserText(messages),
       signal: abortSignal ?? void 0,
-      awaitApproval: this.#criarAwaitApproval(turnoAtual, abortSignal ?? void 0),
+      awaitApproval: this.#createAwaitApproval(currentTurn, abortSignal ?? void 0),
       // M43 — forward per-request context (the seam's `metadata`) to the runner.
       context: metadata
     });
@@ -248,21 +227,20 @@ var InProcessTransport = class {
     return Promise.resolve(null);
   }
   approve(approvalId, decision) {
-    const entrada = this.#pending.get(approvalId);
-    if (entrada === void 0) {
-      return Promise.reject(new Error(`No pending approval '${approvalId}' (unknown or already settled).`));
+    const entry = this.#pending.get(approvalId);
+    if (entry === void 0) {
+      return Promise.reject(
+        new Error(`No pending approval '${approvalId}' (unknown or already settled).`)
+      );
     }
     this.#pending.delete(approvalId);
-    entrada.resolve(decision);
+    entry.resolve(decision);
     return Promise.resolve();
   }
 };
 
 // src/client/channel-transport.ts
 var ChannelTransport = class {
-  static {
-    __name(this, "ChannelTransport");
-  }
   #source;
   constructor(options) {
     this.#source = options.source;
@@ -272,57 +250,57 @@ var ChannelTransport = class {
     const message = extractLastUserText(messages);
     const source = this.#source;
     let closed = false;
-    let teardown = /* @__PURE__ */ __name(() => void 0, "teardown");
-    let detachAbort = /* @__PURE__ */ __name(() => void 0, "detachAbort");
+    let teardown = () => void 0;
+    let detachAbort = () => void 0;
     const stream = new ReadableStream({
       start(controller) {
-        const finish = /* @__PURE__ */ __name((settle) => {
+        const finish = (settle) => {
           if (closed) return;
           closed = true;
           detachAbort();
           settle();
-        }, "finish");
-        teardown = source.start({
-          message,
-          context: metadata
-        }, {
-          onLine: /* @__PURE__ */ __name((line) => {
-            if (closed) return;
-            let parsed;
-            try {
-              parsed = JSON.parse(line);
-            } catch {
-              return;
-            }
-            if (typeof parsed !== "object" || parsed === null || typeof parsed.type !== "string") {
-              return;
+        };
+        teardown = source.start(
+          { message, context: metadata },
+          {
+            onLine: (line) => {
+              if (closed) return;
+              let parsed;
+              try {
+                parsed = JSON.parse(line);
+              } catch {
+                return;
+              }
+              if (typeof parsed !== "object" || parsed === null || typeof parsed.type !== "string") {
+                return;
+              }
+              controller.enqueue(parsed);
+            },
+            onClose: () => {
+              finish(() => {
+                controller.close();
+              });
+            },
+            onError: (err) => {
+              finish(() => {
+                controller.error(err);
+              });
             }
-            controller.enqueue(parsed);
-          }, "onLine"),
-          onClose: /* @__PURE__ */ __name(() => {
-            finish(() => {
-              controller.close();
-            });
-          }, "onClose"),
-          onError: /* @__PURE__ */ __name((err) => {
-            finish(() => {
-              controller.error(err);
-            });
-          }, "onError")
-        });
+          }
+        );
         if (abortSignal !== void 0) {
-          const onAbort = /* @__PURE__ */ __name(() => {
+          const onAbort = () => {
             finish(() => {
               teardown();
               controller.close();
             });
-          }, "onAbort");
+          };
           if (abortSignal.aborted) onAbort();
           else {
             abortSignal.addEventListener("abort", onAbort);
-            detachAbort = /* @__PURE__ */ __name(() => {
+            detachAbort = () => {
               abortSignal.removeEventListener("abort", onAbort);
-            }, "detachAbort");
+            };
           }
         }
       },
@@ -354,24 +332,14 @@ function inputToText(input) {
   if (typeof input === "string") return input;
   return JSON.stringify(input);
 }
-__name(inputToText, "inputToText");
 function buildUserMessage(input) {
   return {
     id: crypto.randomUUID(),
     role: "user",
-    parts: [
-      {
-        type: "text",
-        text: inputToText(input)
-      }
-    ]
+    parts: [{ type: "text", text: inputToText(input) }]
   };
 }
-__name(buildUserMessage, "buildUserMessage");
 var AgentClient = class {
-  static {
-    __name(this, "AgentClient");
-  }
   #transport;
   #chatId = crypto.randomUUID();
   #listeners = /* @__PURE__ */ new Set();
@@ -388,29 +356,25 @@ var AgentClient = class {
   #currentUser;
   /** A stable id for the current turn's assistant (the SDK leaves it empty — we fabricate one). */
   #currentAssistantId = "";
-  #snapshot = {
-    messages: [],
-    thread: [],
-    status: "idle",
-    error: void 0
-  };
+  #snapshot = { messages: [], thread: [], status: "idle", error: void 0 };
   /**
-  * M92 — o prefixo commitado, materializado UMA vez por escrita em vez de por delta de token.
-  *
-  * `#committed` só muda em dois lugares (medido): no `done` de `send()` e em `reset()`. Entre deltas
-  * ele é constante, então reconstruí-lo a cada `#emit` é trabalho que a estrutura já garante inútil.
-  *
-  * Invalidação é **na escrita**, não por comparação: comparar custaria o mesmo O(C) que isto evita, e
-  * memoizar por comprimento erraria em `reset()` — comprimento igual com conteúdo diferente é
-  * possível, e o bug seria invisível.
-  *
-  * Honestidade sobre o tamanho do ganho: medido, o spread custa **0,0062 ms por delta @400 mensagens**
-  * — 3,1 ms num turno de 500 deltas. É real e é micro. A ordem de grandeza deste milestone está no
-  * coalescing abaixo, porque o que pende de cada emit (a derivação da timeline) custa **3,274 ms por
-  * chamada** no mesmo tamanho de thread (M86).
-  */
-  #prefixo = [];
-  /** Coalescing opt-in: `0` (default) emite por delta, como sempre. */
+   * M92 — the committed prefix, materialized ONCE per write instead of once per token delta.
+   *
+   * `#committed` changes in only two places (measured): in `send()`'s `done` and in `reset()`. Between
+   * deltas it is constant, so rebuilding it on every `#emit` is work the structure already guarantees
+   * is useless.
+   *
+   * Invalidation happens **on write**, not by comparison: comparing would cost the same O(C) this
+   * avoids, and memoizing by length would be wrong in `reset()` — equal length with different content
+   * is possible, and the bug would be invisible.
+   *
+   * Honesty about the size of the win: measured, the spread costs **0.0062 ms per delta @400 messages**
+   * — 3.1 ms across a 500-delta turn. It is real and it is micro. The order of magnitude of this
+   * milestone is in the coalescing below, because what hangs off each emit (deriving the timeline)
+   * costs **3.274 ms per call** at the same thread size (M86).
+   */
+  #committedPrefix = [];
+  /** Opt-in coalescing: `0` (the default) emits per delta, as always. */
   #emitIntervalMs;
   #timerDeEmit;
   constructor(transport, contextResolver, options) {
@@ -419,47 +383,39 @@ var AgentClient = class {
     this.#emitIntervalMs = options?.emitIntervalMs ?? 0;
   }
   /** Subscribe to state changes; returns an unsubscribe fn. */
-  subscribe = /* @__PURE__ */ __name((listener) => {
+  subscribe = (listener) => {
     this.#listeners.add(listener);
     return () => {
       this.#listeners.delete(listener);
     };
-  }, "subscribe");
+  };
   /** The current immutable snapshot (stable reference until the next emit). */
-  getSnapshot = /* @__PURE__ */ __name(() => this.#snapshot, "getSnapshot");
+  getSnapshot = () => this.#snapshot;
   /**
-  * Emite AGORA. Usado diretamente nas transições de status — ver `#agendarEmit`.
-  */
+   * Emits NOW. Used directly on status transitions — see `#scheduleEmit`.
+   */
   #emit() {
     if (this.#timerDeEmit !== void 0) {
       clearTimeout(this.#timerDeEmit);
       this.#timerDeEmit = void 0;
     }
-    const cauda = this.#currentUser ? [
-      this.#currentUser,
-      ...this.#messages
-    ] : this.#messages;
-    const thread = this.#prefixo.concat(cauda);
-    this.#snapshot = {
-      messages: this.#messages,
-      thread,
-      status: this.#status,
-      error: this.#error
-    };
+    const tail = this.#currentUser ? [this.#currentUser, ...this.#messages] : this.#messages;
+    const thread = this.#committedPrefix.concat(tail);
+    this.#snapshot = { messages: this.#messages, thread, status: this.#status, error: this.#error };
     for (const listener of this.#listeners) listener();
   }
   /**
-  * Emite por JANELA quando o coalescing está ligado; imediatamente quando não está.
-  *
-  * Borda de saída: o timer emite ao **fim** da janela, com o estado mais recente. O que isto compra
-  * não é um emit mais barato — é **menos emits**, e o que pende de cada um é a derivação de 3,274 ms
-  * medida no M86.
-  *
-  * As transições de status (`done`/`error`/`abort`) NÃO passam por aqui: elas chamam `#emit` direto,
-  * porque um estado final preso num timer de 16 ms é um estado final perdido se o processo sair antes
-  * — e `exec` sai logo após o turno.
-  */
-  #agendarEmit() {
+   * Emits per WINDOW when coalescing is on; immediately when it is off.
+   *
+   * Trailing edge: the timer emits at the **end** of the window, with the most recent state. What this
+   * buys is not a cheaper emit — it is **fewer emits**, and what hangs off each one is the 3.274 ms
+   * derivation measured in M86.
+   *
+   * Status transitions (`done`/`error`/`abort`) do NOT go through here: they call `#emit` directly,
+   * because a final state trapped in a 16 ms timer is a final state lost if the process exits first —
+   * and `exec` exits right after the turn.
+   */
+  #scheduleEmit() {
     if (this.#emitIntervalMs <= 0) {
       this.#emit();
       return;
@@ -471,16 +427,14 @@ var AgentClient = class {
     }, this.#emitIntervalMs);
   }
   #upsert(message) {
-    const next = [
-      ...this.#messages
-    ];
+    const next = [...this.#messages];
     const idx = next.findIndex((existing) => existing.id === message.id);
     if (idx >= 0) next[idx] = message;
     else next.push(message);
     this.#messages = next;
   }
   async #drive(open, controller) {
-    const aborted = /* @__PURE__ */ __name(() => controller.signal.aborted, "aborted");
+    const aborted = () => controller.signal.aborted;
     try {
       const stream = await open();
       if (aborted()) return;
@@ -491,12 +445,9 @@ var AgentClient = class {
       }
       await consumeChunkStream(stream, (message) => {
         if (aborted()) return;
-        const stamped = message.id ? message : {
-          ...message,
-          id: this.#currentAssistantId
-        };
+        const stamped = message.id ? message : { ...message, id: this.#currentAssistantId };
         this.#upsert(stamped);
-        this.#agendarEmit();
+        this.#scheduleEmit();
       });
       if (aborted()) return;
       this.#status = "done";
@@ -509,14 +460,10 @@ var AgentClient = class {
     }
   }
   /** Send a typed input; opens a fresh stream (replaces prior messages). */
-  send = /* @__PURE__ */ __name((input) => {
+  send = (input) => {
     if (this.#status === "done" && this.#currentUser) {
-      this.#committed = [
-        ...this.#committed,
-        this.#currentUser,
-        ...this.#messages
-      ];
-      this.#prefixo = this.#committed;
+      this.#committed = [...this.#committed, this.#currentUser, ...this.#messages];
+      this.#committedPrefix = this.#committed;
     }
     this.abort();
     const controller = new AbortController();
@@ -529,24 +476,25 @@ var AgentClient = class {
     this.#status = "streaming";
     this.#emit();
     const context = this.#contextResolver?.();
-    void this.#drive(() => this.#transport.sendMessages({
-      trigger: "submit-message",
-      chatId: this.#chatId,
-      messageId: void 0,
-      messages: [
-        userMsg
-      ],
-      abortSignal: controller.signal,
-      // Only object inputs flow as the request `body` (the turn text is always in `messages`);
-      // a primitive input is carried by the user message, never spread into the body.
-      body: typeof input === "object" && input !== null ? input : void 0,
-      // M43 — per-request context reaches every transport (headers → HTTP, metadata → in-process/channel).
-      headers: context?.headers,
-      metadata: context?.metadata
-    }), controller);
-  }, "send");
+    void this.#drive(
+      () => this.#transport.sendMessages({
+        trigger: "submit-message",
+        chatId: this.#chatId,
+        messageId: void 0,
+        messages: [userMsg],
+        abortSignal: controller.signal,
+        // Only object inputs flow as the request `body` (the turn text is always in `messages`);
+        // a primitive input is carried by the user message, never spread into the body.
+        body: typeof input === "object" && input !== null ? input : void 0,
+        // M43 — per-request context reaches every transport (headers → HTTP, metadata → in-process/channel).
+        headers: context?.headers,
+        metadata: context?.metadata
+      }),
+      controller
+    );
+  };
   /** Resume an interrupted stream via the transport's `reconnectToStream` (no-op when unavailable). */
-  reconnect = /* @__PURE__ */ __name(() => {
+  reconnect = () => {
     const controller = new AbortController();
     this.#controller = controller;
     if (!this.#currentAssistantId) this.#currentAssistantId = crypto.randomUUID();
@@ -554,55 +502,52 @@ var AgentClient = class {
     this.#status = "streaming";
     this.#emit();
     const context = this.#contextResolver?.();
-    void this.#drive(() => this.#transport.reconnectToStream({
-      chatId: this.#chatId,
-      headers: context?.headers,
-      metadata: context?.metadata
-    }), controller);
-  }, "reconnect");
+    void this.#drive(
+      () => this.#transport.reconnectToStream({
+        chatId: this.#chatId,
+        headers: context?.headers,
+        metadata: context?.metadata
+      }),
+      controller
+    );
+  };
   /** Abort an in-flight stream (not an error — leaves messages as-is). */
-  abort = /* @__PURE__ */ __name(() => {
+  abort = () => {
     this.#controller?.abort();
     this.#controller = null;
     if (this.#status === "streaming") {
       this.#status = this.#committed.length > 0 || this.#messages.length > 0 ? "done" : "idle";
       this.#emit();
     }
-  }, "abort");
+  };
   /** Clear messages + error, back to idle. */
-  reset = /* @__PURE__ */ __name(() => {
+  reset = () => {
     this.abort();
     this.#messages = [];
     this.#committed = [];
-    this.#prefixo = this.#committed;
+    this.#committedPrefix = this.#committed;
     this.#currentUser = void 0;
     this.#error = void 0;
     this.#status = "idle";
     this.#emit();
-  }, "reset");
+  };
   /** Settle a paused HITL approval via the transport's HITL path (HTTP POST or inline callback). */
-  approve = /* @__PURE__ */ __name(async (approvalId, decision) => {
+  approve = async (approvalId, decision) => {
     await this.#transport.approve?.(approvalId, decision);
-  }, "approve");
+  };
 };
 
 // src/client/agent-handle.ts
 function agentHandle(path) {
   return {
     path,
-    inProcess: /* @__PURE__ */ __name((run) => new InProcessTransport({
-      run
-    }), "inProcess"),
-    channel: /* @__PURE__ */ __name((source) => new ChannelTransport({
-      source
-    }), "channel")
+    inProcess: (run) => new InProcessTransport({ run }),
+    channel: (source) => new ChannelTransport({ source })
   };
 }
-__name(agentHandle, "agentHandle");
 function isAgentHandle(value) {
   return typeof value === "object" && value !== null && typeof value.path === "string" && typeof value.sendMessages !== "function";
 }
-__name(isAgentHandle, "isAgentHandle");
 
 export {
   consumeUIMessageStream,
@@ -617,4 +562,4 @@ export {
   agentHandle,
   isAgentHandle
 };
-//# sourceMappingURL=chunk-CVDPGEJF.js.map
+//# sourceMappingURL=chunk-FJA4QQLZ.js.map