lody 0.80.0 → 0.81.1

package/dist/chunks/{package-qnDHmQq4.js → acp-CrvzLY5A.js}

@@ -2466,8 +2466,8 @@ class ConnectionBuilder {
   /**
    * Sets a diagnostic name used by handlers created from this builder.
    */
-  name(name2) {
-    this.connectionName = name2;
+  name(name) {
+    this.connectionName = name;
     return this;
   }
   /**
@@ -3633,6 +3633,37 @@ class ClientApp {
     };
   }
 }
+const legacyAgentRequestMethods = /* @__PURE__ */ new Set([
+  AGENT_METHODS.initialize,
+  AGENT_METHODS.authenticate,
+  AGENT_METHODS.providers_list,
+  AGENT_METHODS.providers_set,
+  AGENT_METHODS.providers_disable,
+  AGENT_METHODS.session_new,
+  AGENT_METHODS.session_load,
+  AGENT_METHODS.session_set_mode,
+  AGENT_METHODS.session_set_config_option,
+  AGENT_METHODS.session_prompt,
+  AGENT_METHODS.session_list,
+  AGENT_METHODS.session_delete,
+  AGENT_METHODS.session_fork,
+  AGENT_METHODS.session_resume,
+  AGENT_METHODS.session_close,
+  AGENT_METHODS.logout,
+  AGENT_METHODS.nes_start,
+  AGENT_METHODS.nes_suggest,
+  AGENT_METHODS.nes_close
+]);
+const legacyAgentNotificationMethods = /* @__PURE__ */ new Set([
+  AGENT_METHODS.session_cancel,
+  AGENT_METHODS.nes_accept,
+  AGENT_METHODS.nes_reject,
+  AGENT_METHODS.document_did_open,
+  AGENT_METHODS.document_did_change,
+  AGENT_METHODS.document_did_close,
+  AGENT_METHODS.document_did_save,
+  AGENT_METHODS.document_did_focus
+]);
 const legacyClientRequestMethods = /* @__PURE__ */ new Set([
   CLIENT_METHODS.session_request_permission,
   CLIENT_METHODS.fs_write_text_file,
@@ -3648,6 +3679,100 @@ const legacyClientNotificationMethods = /* @__PURE__ */ new Set([
   CLIENT_METHODS.session_update,
   CLIENT_METHODS.elicitation_complete
 ]);
+function legacyAgentApp(implementation) {
+  const app = agent().onRequest(AGENT_METHODS.initialize, (ctx) => implementation.initialize(ctx.params)).onRequest(AGENT_METHODS.session_new, (ctx) => implementation.newSession(ctx.params)).onRequest(AGENT_METHODS.authenticate, async (ctx) => await implementation.authenticate(ctx.params) ?? {}).onRequest(AGENT_METHODS.session_prompt, (ctx) => implementation.prompt(ctx.params)).onNotification(AGENT_METHODS.session_cancel, (ctx) => implementation.cancel(ctx.params));
+  if (implementation.loadSession) {
+    app.onRequest(AGENT_METHODS.session_load, (ctx) => implementation.loadSession(ctx.params));
+  }
+  if (implementation.listSessions) {
+    app.onRequest(AGENT_METHODS.session_list, (ctx) => implementation.listSessions(ctx.params));
+  }
+  if (implementation.deleteSession) {
+    app.onRequest(AGENT_METHODS.session_delete, async (ctx) => await implementation.deleteSession(ctx.params) ?? {});
+  }
+  if (implementation.unstable_forkSession) {
+    app.onRequest(AGENT_METHODS.session_fork, (ctx) => implementation.unstable_forkSession(ctx.params));
+  }
+  if (implementation.resumeSession) {
+    app.onRequest(AGENT_METHODS.session_resume, (ctx) => implementation.resumeSession(ctx.params));
+  }
+  if (implementation.closeSession) {
+    app.onRequest(AGENT_METHODS.session_close, async (ctx) => await implementation.closeSession(ctx.params) ?? {});
+  }
+  if (implementation.setSessionMode) {
+    app.onRequest(AGENT_METHODS.session_set_mode, async (ctx) => await implementation.setSessionMode(ctx.params) ?? {});
+  }
+  if (implementation.setSessionConfigOption) {
+    app.onRequest(AGENT_METHODS.session_set_config_option, (ctx) => implementation.setSessionConfigOption(ctx.params));
+  }
+  if (implementation.unstable_listProviders) {
+    app.onRequest(AGENT_METHODS.providers_list, (ctx) => implementation.unstable_listProviders(ctx.params));
+  }
+  if (implementation.unstable_setProvider) {
+    app.onRequest(AGENT_METHODS.providers_set, async (ctx) => await implementation.unstable_setProvider(ctx.params) ?? {});
+  }
+  if (implementation.unstable_disableProvider) {
+    app.onRequest(AGENT_METHODS.providers_disable, async (ctx) => await implementation.unstable_disableProvider(ctx.params) ?? {});
+  }
+  if (implementation.logout) {
+    app.onRequest(AGENT_METHODS.logout, async (ctx) => await implementation.logout(ctx.params) ?? {});
+  }
+  if (implementation.unstable_startNes) {
+    app.onRequest(AGENT_METHODS.nes_start, (ctx) => implementation.unstable_startNes(ctx.params));
+  }
+  if (implementation.unstable_suggestNes) {
+    app.onRequest(AGENT_METHODS.nes_suggest, (ctx) => implementation.unstable_suggestNes(ctx.params));
+  }
+  if (implementation.unstable_closeNes) {
+    app.onRequest(AGENT_METHODS.nes_close, async (ctx) => await implementation.unstable_closeNes(ctx.params) ?? {});
+  }
+  if (implementation.unstable_didOpenDocument) {
+    app.onNotification(AGENT_METHODS.document_did_open, (ctx) => implementation.unstable_didOpenDocument(ctx.params));
+  }
+  if (implementation.unstable_didChangeDocument) {
+    app.onNotification(AGENT_METHODS.document_did_change, (ctx) => implementation.unstable_didChangeDocument(ctx.params));
+  }
+  if (implementation.unstable_didCloseDocument) {
+    app.onNotification(AGENT_METHODS.document_did_close, (ctx) => implementation.unstable_didCloseDocument(ctx.params));
+  }
+  if (implementation.unstable_didSaveDocument) {
+    app.onNotification(AGENT_METHODS.document_did_save, (ctx) => implementation.unstable_didSaveDocument(ctx.params));
+  }
+  if (implementation.unstable_didFocusDocument) {
+    app.onNotification(AGENT_METHODS.document_did_focus, (ctx) => implementation.unstable_didFocusDocument(ctx.params));
+  }
+  if (implementation.unstable_acceptNes) {
+    app.onNotification(AGENT_METHODS.nes_accept, (ctx) => implementation.unstable_acceptNes(ctx.params));
+  }
+  if (implementation.unstable_rejectNes) {
+    app.onNotification(AGENT_METHODS.nes_reject, (ctx) => implementation.unstable_rejectNes(ctx.params));
+  }
+  if (implementation.extMethod) {
+    app[appBuilder]().withHandler({
+      handleMessage: async (message) => {
+        if (message.kind !== "request" || legacyAgentRequestMethods.has(message.method)) {
+          return Handled.no(message);
+        }
+        await message.responder.respond(await implementation.extMethod(message.method, message.params));
+        return Handled.yes();
+      },
+      describe: () => "legacy-agent-extension-request"
+    });
+  }
+  if (implementation.extNotification) {
+    app[appBuilder]().withHandler({
+      handleMessage: async (message) => {
+        if (message.kind !== "notification" || legacyAgentNotificationMethods.has(message.method)) {
+          return Handled.no(message);
+        }
+        await implementation.extNotification(message.method, message.params);
+        return Handled.yes();
+      },
+      describe: () => "legacy-agent-extension-notification"
+    });
+  }
+  return app;
+}
 function legacyClientApp(implementation) {
   const app = client().onRequest(CLIENT_METHODS.session_request_permission, (ctx) => implementation.requestPermission(ctx.params)).onNotification(CLIENT_METHODS.session_update, (ctx) => implementation.sessionUpdate(ctx.params)).onRequest(CLIENT_METHODS.fs_write_text_file, async (ctx) => await implementation.writeTextFile?.(ctx.params) ?? {}).onRequest(CLIENT_METHODS.fs_read_text_file, async (ctx) => await implementation.readTextFile?.(ctx.params)).onRequest(CLIENT_METHODS.terminal_create, async (ctx) => await implementation.createTerminal?.(ctx.params)).onRequest(CLIENT_METHODS.terminal_output, async (ctx) => await implementation.terminalOutput?.(ctx.params)).onRequest(CLIENT_METHODS.terminal_release, async (ctx) => await implementation.releaseTerminal?.(ctx.params) ?? {}).onRequest(CLIENT_METHODS.terminal_wait_for_exit, async (ctx) => await implementation.waitForTerminalExit?.(ctx.params)).onRequest(CLIENT_METHODS.terminal_kill, async (ctx) => await implementation.killTerminal?.(ctx.params) ?? {});
   if (implementation.unstable_createElicitation) {
@@ -3682,6 +3807,265 @@ function legacyClientApp(implementation) {
   }
   return app;
 }
+class AgentSideConnection {
+  connection;
+  /**
+   * Creates a new agent-side connection to a client.
+   *
+   * This establishes the communication channel from the agent's perspective
+   * following the ACP specification.
+   *
+   * @param toAgent - A function that creates an Agent handler to process incoming client requests
+   * @param stream - The bidirectional message stream for communication. Typically created using
+   *                 {@link ndJsonStream} for stdio-based connections.
+   *
+   * See protocol docs: [Communication Model](https://agentclientprotocol.com/protocol/overview#communication-model)
+   *
+   * @deprecated Prefer `agent({ name }).connect(stream)`.
+   */
+  constructor(toAgent, stream) {
+    this.connection = legacyAgentApp(toAgent(this))[appBuilder]().connect(stream, stableConnectionOptions);
+  }
+  /**
+   * Handles session update notifications from the agent.
+   *
+   * This is a notification endpoint (no response expected) that sends
+   * real-time updates about session progress, including message chunks,
+   * tool calls, and execution plans.
+   *
+   * Note: Clients SHOULD continue accepting tool call updates even after
+   * sending a `session/cancel` notification, as the agent may send final
+   * updates before responding with the cancelled stop reason.
+   *
+   * See protocol docs: [Agent Reports Output](https://agentclientprotocol.com/protocol/prompt-turn#3-agent-reports-output)
+   */
+  sessionUpdate(params) {
+    return this.connection.sendNotification(CLIENT_METHODS.session_update, params);
+  }
+  /**
+   * Requests permission from the user for a tool call operation.
+   *
+   * Called by the agent when it needs user authorization before executing
+   * a potentially sensitive operation. The client should present the options
+   * to the user and return their decision.
+   *
+   * If the client cancels the prompt turn via `session/cancel`, it MUST
+   * respond to this request with `RequestPermissionOutcome::Cancelled`.
+   *
+   * See protocol docs: [Requesting Permission](https://agentclientprotocol.com/protocol/tool-calls#requesting-permission)
+   */
+  requestPermission(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.session_request_permission, params);
+  }
+  /**
+   * Reads content from a text file in the client's file system.
+   *
+   * Only available if the client advertises the `fs.readTextFile` capability.
+   * Allows the agent to access file contents within the client's environment.
+   *
+   * See protocol docs: [Client](https://agentclientprotocol.com/protocol/overview#client)
+   */
+  readTextFile(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.fs_read_text_file, params);
+  }
+  /**
+   * Writes content to a text file in the client's file system.
+   *
+   * Only available if the client advertises the `fs.writeTextFile` capability.
+   * Allows the agent to create or modify files within the client's environment.
+   *
+   * See protocol docs: [Client](https://agentclientprotocol.com/protocol/overview#client)
+   */
+  writeTextFile(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.fs_write_text_file, params, emptyObjectResponse);
+  }
+  /**
+   * Executes a command in a new terminal.
+   *
+   * Returns a `TerminalHandle` that can be used to get output, wait for exit,
+   * kill the command, or release the terminal.
+   *
+   * The terminal can also be embedded in tool calls by using its ID in
+   * `ToolCallContent` with type "terminal".
+   *
+   * @param params - The terminal creation parameters
+   * @returns A handle to control and monitor the terminal
+   */
+  createTerminal(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_create, params, (response) => TerminalHandle.create(response.terminalId, params.sessionId, this.connection));
+  }
+  /**
+   * **UNSTABLE**
+   *
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Creates an elicitation to request input from the user.
+   *
+   * @experimental
+   */
+  unstable_createElicitation(params) {
+    return this.connection.sendRequest(CLIENT_METHODS.elicitation_create, params);
+  }
+  /**
+   * **UNSTABLE**
+   *
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the client that a URL-based elicitation is complete.
+   *
+   * @experimental
+   */
+  unstable_completeElicitation(params) {
+    return this.connection.sendNotification(CLIENT_METHODS.elicitation_complete, params);
+  }
+  request(method, params, options) {
+    const spec = clientRequestSpecsByMethod[method];
+    return this.connection.sendRequest(method, params, spec?.mapResponse, options);
+  }
+  notify(method, params) {
+    return this.connection.sendNotification(method, params);
+  }
+  /**
+   * Extension method.
+   *
+   * @deprecated Use {@link request}.
+   */
+  extMethod(method, params) {
+    return this.request(method, params);
+  }
+  /**
+   * Extension notification.
+   *
+   * @deprecated Use {@link notify}.
+   */
+  extNotification(method, params) {
+    return this.notify(method, params);
+  }
+  /**
+   * AbortSignal that aborts when the connection closes.
+   *
+   * This signal can be used to:
+   * - Listen for connection closure: `connection.signal.addEventListener('abort', () => {...})`
+   * - Check connection status synchronously: `if (connection.signal.aborted) {...}`
+   * - Pass to other APIs (fetch, setTimeout) for automatic cancellation
+   *
+   * The connection closes when the underlying stream ends, either normally or due to an error.
+   *
+   * @example
+   * ```typescript
+   * const connection = new AgentSideConnection(agent, stream);
+   *
+   * // Listen for closure
+   * connection.signal.addEventListener('abort', () => {
+   *   console.log('Connection closed - performing cleanup');
+   * });
+   *
+   * // Check status
+   * if (connection.signal.aborted) {
+   *   console.log('Connection is already closed');
+   * }
+   *
+   * // Pass to other APIs
+   * fetch(url, { signal: connection.signal });
+   * ```
+   */
+  get signal() {
+    return this.connection.signal;
+  }
+  /**
+   * Promise that resolves when the connection closes.
+   *
+   * The connection closes when the underlying stream ends, either normally or due to an error.
+   * Once closed, the connection cannot send or receive any more messages.
+   *
+   * This is useful for async/await style cleanup:
+   *
+   * @example
+   * ```typescript
+   * const connection = new AgentSideConnection(agent, stream);
+   * await connection.closed;
+   * console.log('Connection closed - performing cleanup');
+   * ```
+   */
+  get closed() {
+    return this.connection.closed;
+  }
+}
+class TerminalHandle {
+  /**
+   * Terminal identifier returned by `terminal/create`.
+   */
+  id;
+  sessionId;
+  connection;
+  constructor(id, sessionId, conn) {
+    this.id = id;
+    this.sessionId = sessionId;
+    this.connection = conn;
+  }
+  /** @internal */
+  static create(id, sessionId, conn) {
+    return new TerminalHandle(id, sessionId, conn);
+  }
+  /**
+   * Gets the current terminal output without waiting for the command to exit.
+   */
+  currentOutput() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_output, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    });
+  }
+  /**
+   * Waits for the terminal command to complete and returns its exit status.
+   */
+  waitForExit() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_wait_for_exit, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    });
+  }
+  /**
+   * Kills the terminal command without releasing the terminal.
+   *
+   * The terminal remains valid after killing, allowing you to:
+   * - Get the final output with `currentOutput()`
+   * - Check the exit status
+   * - Release the terminal when done
+   *
+   * Useful for implementing timeouts or cancellation.
+   */
+  kill() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_kill, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    }, emptyObjectResponse);
+  }
+  /**
+   * Releases the terminal and frees all associated resources.
+   *
+   * If the command is still running, it will be killed.
+   * After release, the terminal ID becomes invalid and cannot be used
+   * with other terminal methods.
+   *
+   * Tool calls that already reference this terminal will continue to
+   * display its output.
+   *
+   * **Important:** Always call this method when done with the terminal.
+   */
+  release() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_release, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    }, emptyObjectResponse);
+  }
+  /**
+   * Releases the terminal when used with `await using`.
+   */
+  async [Symbol.asyncDispose]() {
+    await this.release();
+  }
+}
 class ClientSideConnection {
   connection;
   /**
@@ -4113,21 +4497,13 @@ class ClientSideConnection {
     return this.connection.closed;
   }
 }
-const name = "acp-extension-claude";
-const version = "0.66.0";
-const dependencies = { "@anthropic-ai/claude-agent-sdk": "0.3.220" };
-const packageJson = {
-  name,
-  version,
-  dependencies
-};
 export {
+  AgentSideConnection as A,
   ClientSideConnection as C,
   PROTOCOL_VERSION as P,
   RequestError as R,
   CreateElicitationResponse as a,
   agent as b,
   methods as m,
-  ndJsonStream as n,
-  packageJson as p
+  ndJsonStream as n
 };

package/dist/chunks/package-Ce-NgzCA.js

@@ -0,0 +1,11 @@
+const name = "acp-extension-claude";
+const version = "0.66.0";
+const dependencies = { "@anthropic-ai/claude-agent-sdk": "0.3.220" };
+const packageJson = {
+  name,
+  version,
+  dependencies
+};
+export {
+  packageJson as p
+};