@posthog/agent 1.25.0 → 1.26.0

package/dist/_virtual/_tslib.js

@@ -0,0 +1,74 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __addDisposableResource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+
+}
+
+var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function __disposeResources(env) {
+    function fail(e) {
+        env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+        env.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+        while (r = env.stack.pop()) {
+            try {
+                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                if (r.dispose) {
+                    var result = r.dispose.call(r.value);
+                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                else s |= 1;
+            }
+            catch (e) {
+                fail(e);
+            }
+        }
+        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+        if (env.hasError) throw env.error;
+    }
+    return next();
+}
+
+export { __addDisposableResource, __disposeResources };
+//# sourceMappingURL=_tslib.js.map

package/dist/_virtual/_tslib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_tslib.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/_virtual/index.js

@@ -1,4 +1,4 @@
-var dist = {exports: {}};
+var discriminator = {};
 
-export { dist as __module };
+export { discriminator as __exports };
 //# sourceMappingURL=index.js.map

package/dist/_virtual/index2.js

@@ -1,4 +1,4 @@
-var discriminator = {};
+var dist = {exports: {}};
 
-export { discriminator as __exports };
+export { dist as __module };
 //# sourceMappingURL=index2.js.map

package/dist/_virtual/index8.js

@@ -1,4 +1,4 @@
-var codegen = {};
+var validate = {};
 
-export { codegen as __exports };
+export { validate as __exports };
 //# sourceMappingURL=index8.js.map

package/dist/_virtual/index9.js

@@ -1,4 +1,4 @@
-var validate = {};
+var codegen = {};
 
-export { validate as __exports };
+export { codegen as __exports };
 //# sourceMappingURL=index9.js.map

package/dist/node_modules/@agentclientprotocol/sdk/dist/acp.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { CLIENT_METHODS, AGENT_METHODS, setSessionModelRequestSchema, promptRequestSchema, authenticateRequestSchema, setSessionModeRequestSchema, loadSessionRequestSchema, newSessionRequestSchema, initializeRequestSchema, cancelNotificationSchema } from './schema.js';
-export { agentCapabilitiesSchema, agentNotificationSchema, agentOutgoingMessageSchema, agentRequestSchema, agentResponseSchema, annotationsSchema, authMethodSchema, authenticateResponseSchema, availableCommandInputSchema, availableCommandSchema, blobResourceContentsSchema, clientCapabilitiesSchema, clientNotificationSchema, clientOutgoingMessageSchema, clientRequestSchema, clientResponseSchema, contentBlockSchema, createTerminalRequestSchema, createTerminalResponseSchema, embeddedResourceResourceSchema, envVariableSchema, errorSchema, extMethodRequest1Schema, extMethodRequestSchema, extMethodResponse1Schema, extMethodResponseSchema, extNotification1Schema, extNotificationSchema, fileSystemCapabilitySchema, httpHeaderSchema, implementationSchema, initializeResponseSchema, killTerminalCommandRequestSchema, killTerminalResponseSchema, loadSessionResponseSchema, mcpCapabilitiesSchema, mcpServerSchema, modelInfoSchema, newSessionResponseSchema, notification1Schema, notificationSchema, null1Schema, nullSchema, number1Schema, numberSchema, permissionOptionSchema, planEntrySchema, promptCapabilitiesSchema, promptResponseSchema, readTextFileRequestSchema, readTextFileResponseSchema, releaseTerminalRequestSchema, releaseTerminalResponseSchema, request1Schema, requestPermissionRequestSchema, requestPermissionResponseSchema, requestSchema, response1Schema, responseSchema, roleSchema, sessionModeIdSchema, sessionModeSchema, sessionModeStateSchema, sessionModelStateSchema, sessionNotificationSchema, setSessionModeResponseSchema, setSessionModelResponseSchema, stdioSchema, string1Schema, stringSchema, terminalExitStatusSchema, terminalOutputRequestSchema, terminalOutputResponseSchema, textResourceContentsSchema, toolCallContentSchema, toolCallLocationSchema, toolCallStatusSchema, toolKindSchema, unstructuredCommandInputSchema, waitForTerminalExitRequestSchema, waitForTerminalExitResponseSchema, writeTextFileRequestSchema, writeTextFileResponseSchema } from './schema.js';
+import { CLIENT_METHODS, AGENT_METHODS, setSessionModelRequestSchema, promptRequestSchema, authenticateRequestSchema, setSessionModeRequestSchema, loadSessionRequestSchema, newSessionRequestSchema, initializeRequestSchema, cancelNotificationSchema, killTerminalCommandRequestSchema, waitForTerminalExitRequestSchema, releaseTerminalRequestSchema, terminalOutputRequestSchema, createTerminalRequestSchema, requestPermissionRequestSchema, readTextFileRequestSchema, writeTextFileRequestSchema, sessionNotificationSchema } from './schema.js';
+export { PROTOCOL_VERSION, agentCapabilitiesSchema, agentNotificationSchema, agentOutgoingMessageSchema, agentRequestSchema, agentResponseSchema, annotationsSchema, authMethodSchema, authenticateResponseSchema, availableCommandInputSchema, availableCommandSchema, blobResourceContentsSchema, clientCapabilitiesSchema, clientNotificationSchema, clientOutgoingMessageSchema, clientRequestSchema, clientResponseSchema, contentBlockSchema, createTerminalResponseSchema, embeddedResourceResourceSchema, envVariableSchema, errorSchema, extMethodRequest1Schema, extMethodRequestSchema, extMethodResponse1Schema, extMethodResponseSchema, extNotification1Schema, extNotificationSchema, fileSystemCapabilitySchema, httpHeaderSchema, implementationSchema, initializeResponseSchema, killTerminalResponseSchema, loadSessionResponseSchema, mcpCapabilitiesSchema, mcpServerSchema, modelInfoSchema, newSessionResponseSchema, notification1Schema, notificationSchema, null1Schema, nullSchema, number1Schema, numberSchema, permissionOptionSchema, planEntrySchema, promptCapabilitiesSchema, promptResponseSchema, readTextFileResponseSchema, releaseTerminalResponseSchema, request1Schema, requestPermissionResponseSchema, requestSchema, response1Schema, responseSchema, roleSchema, sessionModeIdSchema, sessionModeSchema, sessionModeStateSchema, sessionModelStateSchema, setSessionModeResponseSchema, setSessionModelResponseSchema, stdioSchema, string1Schema, stringSchema, terminalExitStatusSchema, terminalOutputResponseSchema, textResourceContentsSchema, toolCallContentSchema, toolCallLocationSchema, toolCallStatusSchema, toolKindSchema, unstructuredCommandInputSchema, waitForTerminalExitResponseSchema, writeTextFileResponseSchema } from './schema.js';
 
 /**
  * An agent-side connection to a client.
@@ -314,6 +314,287 @@ class TerminalHandle {
         await this.release();
     }
 }
+/**
+ * A client-side connection to an agent.
+ *
+ * This class provides the client's view of an ACP connection, allowing
+ * clients (such as code editors) to communicate with agents. It implements
+ * the {@link Agent} interface to provide methods for initializing sessions, sending
+ * prompts, and managing the agent lifecycle.
+ *
+ * See protocol docs: [Client](https://agentclientprotocol.com/protocol/overview#client)
+ */
+class ClientSideConnection {
+    #connection;
+    /**
+     * Creates a new client-side connection to an agent.
+     *
+     * This establishes the communication channel between a client and agent
+     * following the ACP specification.
+     *
+     * @param toClient - A function that creates a Client handler to process incoming agent 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)
+     */
+    constructor(toClient, stream) {
+        const client = toClient(this);
+        const requestHandler = async (method, params) => {
+            switch (method) {
+                case CLIENT_METHODS.fs_write_text_file: {
+                    const validatedParams = writeTextFileRequestSchema.parse(params);
+                    return client.writeTextFile?.(validatedParams);
+                }
+                case CLIENT_METHODS.fs_read_text_file: {
+                    const validatedParams = readTextFileRequestSchema.parse(params);
+                    return client.readTextFile?.(validatedParams);
+                }
+                case CLIENT_METHODS.session_request_permission: {
+                    const validatedParams = requestPermissionRequestSchema.parse(params);
+                    return client.requestPermission(validatedParams);
+                }
+                case CLIENT_METHODS.terminal_create: {
+                    const validatedParams = createTerminalRequestSchema.parse(params);
+                    return client.createTerminal?.(validatedParams);
+                }
+                case CLIENT_METHODS.terminal_output: {
+                    const validatedParams = terminalOutputRequestSchema.parse(params);
+                    return client.terminalOutput?.(validatedParams);
+                }
+                case CLIENT_METHODS.terminal_release: {
+                    const validatedParams = releaseTerminalRequestSchema.parse(params);
+                    const result = await client.releaseTerminal?.(validatedParams);
+                    return result ?? {};
+                }
+                case CLIENT_METHODS.terminal_wait_for_exit: {
+                    const validatedParams = waitForTerminalExitRequestSchema.parse(params);
+                    return client.waitForTerminalExit?.(validatedParams);
+                }
+                case CLIENT_METHODS.terminal_kill: {
+                    const validatedParams = killTerminalCommandRequestSchema.parse(params);
+                    const result = await client.killTerminal?.(validatedParams);
+                    return result ?? {};
+                }
+                default:
+                    // Handle extension methods (any method starting with '_')
+                    if (method.startsWith("_")) {
+                        const customMethod = method.substring(1);
+                        if (!client.extMethod) {
+                            throw RequestError.methodNotFound(method);
+                        }
+                        return client.extMethod(customMethod, params);
+                    }
+                    throw RequestError.methodNotFound(method);
+            }
+        };
+        const notificationHandler = async (method, params) => {
+            switch (method) {
+                case CLIENT_METHODS.session_update: {
+                    const validatedParams = sessionNotificationSchema.parse(params);
+                    return client.sessionUpdate(validatedParams);
+                }
+                default:
+                    // Handle extension notifications (any method starting with '_')
+                    if (method.startsWith("_")) {
+                        const customMethod = method.substring(1);
+                        if (!client.extNotification) {
+                            return;
+                        }
+                        return client.extNotification(customMethod, params);
+                    }
+                    throw RequestError.methodNotFound(method);
+            }
+        };
+        this.#connection = new Connection(requestHandler, notificationHandler, stream);
+    }
+    /**
+     * Establishes the connection with a client and negotiates protocol capabilities.
+     *
+     * This method is called once at the beginning of the connection to:
+     * - Negotiate the protocol version to use
+     * - Exchange capability information between client and agent
+     * - Determine available authentication methods
+     *
+     * The agent should respond with its supported protocol version and capabilities.
+     *
+     * See protocol docs: [Initialization](https://agentclientprotocol.com/protocol/initialization)
+     */
+    async initialize(params) {
+        return await this.#connection.sendRequest(AGENT_METHODS.initialize, params);
+    }
+    /**
+     * Creates a new conversation session with the agent.
+     *
+     * Sessions represent independent conversation contexts with their own history and state.
+     *
+     * The agent should:
+     * - Create a new session context
+     * - Connect to any specified MCP servers
+     * - Return a unique session ID for future requests
+     *
+     * May return an `auth_required` error if the agent requires authentication.
+     *
+     * See protocol docs: [Session Setup](https://agentclientprotocol.com/protocol/session-setup)
+     */
+    async newSession(params) {
+        return await this.#connection.sendRequest(AGENT_METHODS.session_new, params);
+    }
+    /**
+     * Loads an existing session to resume a previous conversation.
+     *
+     * This method is only available if the agent advertises the `loadSession` capability.
+     *
+     * The agent should:
+     * - Restore the session context and conversation history
+     * - Connect to the specified MCP servers
+     * - Stream the entire conversation history back to the client via notifications
+     *
+     * See protocol docs: [Loading Sessions](https://agentclientprotocol.com/protocol/session-setup#loading-sessions)
+     */
+    async loadSession(params) {
+        return ((await this.#connection.sendRequest(AGENT_METHODS.session_load, params)) ?? {});
+    }
+    /**
+     * Sets the operational mode for a session.
+     *
+     * Allows switching between different agent modes (e.g., "ask", "architect", "code")
+     * that affect system prompts, tool availability, and permission behaviors.
+     *
+     * The mode must be one of the modes advertised in `availableModes` during session
+     * creation or loading. Agents may also change modes autonomously and notify the
+     * client via `current_mode_update` notifications.
+     *
+     * This method can be called at any time during a session, whether the Agent is
+     * idle or actively generating a turn.
+     *
+     * See protocol docs: [Session Modes](https://agentclientprotocol.com/protocol/session-modes)
+     */
+    async setSessionMode(params) {
+        return ((await this.#connection.sendRequest(AGENT_METHODS.session_set_mode, params)) ?? {});
+    }
+    /**
+     * **UNSTABLE**
+     *
+     * This capability is not part of the spec yet, and may be removed or changed at any point.
+     *
+     * Select a model for a given session.
+     */
+    async setSessionModel(params) {
+        return ((await this.#connection.sendRequest(AGENT_METHODS.session_set_model, params)) ?? {});
+    }
+    /**
+     * Authenticates the client using the specified authentication method.
+     *
+     * Called when the agent requires authentication before allowing session creation.
+     * The client provides the authentication method ID that was advertised during initialization.
+     *
+     * After successful authentication, the client can proceed to create sessions with
+     * `newSession` without receiving an `auth_required` error.
+     *
+     * See protocol docs: [Initialization](https://agentclientprotocol.com/protocol/initialization)
+     */
+    async authenticate(params) {
+        return ((await this.#connection.sendRequest(AGENT_METHODS.authenticate, params)) ?? {});
+    }
+    /**
+     * Processes a user prompt within a session.
+     *
+     * This method handles the whole lifecycle of a prompt:
+     * - Receives user messages with optional context (files, images, etc.)
+     * - Processes the prompt using language models
+     * - Reports language model content and tool calls to the Clients
+     * - Requests permission to run tools
+     * - Executes any requested tool calls
+     * - Returns when the turn is complete with a stop reason
+     *
+     * See protocol docs: [Prompt Turn](https://agentclientprotocol.com/protocol/prompt-turn)
+     */
+    async prompt(params) {
+        return await this.#connection.sendRequest(AGENT_METHODS.session_prompt, params);
+    }
+    /**
+     * Cancels ongoing operations for a session.
+     *
+     * This is a notification sent by the client to cancel an ongoing prompt turn.
+     *
+     * Upon receiving this notification, the Agent SHOULD:
+     * - Stop all language model requests as soon as possible
+     * - Abort all tool call invocations in progress
+     * - Send any pending `session/update` notifications
+     * - Respond to the original `session/prompt` request with `StopReason::Cancelled`
+     *
+     * See protocol docs: [Cancellation](https://agentclientprotocol.com/protocol/prompt-turn#cancellation)
+     */
+    async cancel(params) {
+        return await this.#connection.sendNotification(AGENT_METHODS.session_cancel, params);
+    }
+    /**
+     * Extension method
+     *
+     * Allows the Client to send an arbitrary request that is not part of the ACP spec.
+     */
+    async extMethod(method, params) {
+        return await this.#connection.sendRequest(`_${method}`, params);
+    }
+    /**
+     * Extension notification
+     *
+     * Allows the Client to send an arbitrary notification that is not part of the ACP spec.
+     */
+    async extNotification(method, params) {
+        return await this.#connection.sendNotification(`_${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 ClientSideConnection(client, 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 ClientSideConnection(client, stream);
+     * await connection.closed;
+     * console.log('Connection closed - performing cleanup');
+     * ```
+     */
+    get closed() {
+        return this.#connection.closed;
+    }
+}
 class Connection {
     #pendingResponses = new Map();
     #nextRequestId = 0;
@@ -606,5 +887,5 @@ class RequestError extends Error {
     }
 }
 
-export { AGENT_METHODS, AgentSideConnection, CLIENT_METHODS, RequestError, TerminalHandle, authenticateRequestSchema, cancelNotificationSchema, initializeRequestSchema, loadSessionRequestSchema, newSessionRequestSchema, promptRequestSchema, setSessionModeRequestSchema, setSessionModelRequestSchema };
+export { AGENT_METHODS, AgentSideConnection, CLIENT_METHODS, ClientSideConnection, RequestError, TerminalHandle, authenticateRequestSchema, cancelNotificationSchema, createTerminalRequestSchema, initializeRequestSchema, killTerminalCommandRequestSchema, loadSessionRequestSchema, newSessionRequestSchema, promptRequestSchema, readTextFileRequestSchema, releaseTerminalRequestSchema, requestPermissionRequestSchema, sessionNotificationSchema, setSessionModeRequestSchema, setSessionModelRequestSchema, terminalOutputRequestSchema, waitForTerminalExitRequestSchema, writeTextFileRequestSchema };
 //# sourceMappingURL=acp.js.map