@wyrd-company/ahp-server 0.1.0

package/dist/src/server.d.ts

@@ -0,0 +1,51 @@
+import { type Message, type StateAction } from '@microsoft/agent-host-protocol';
+import type { AhpServerOptions, ServerTransport } from './types.js';
+export declare class AhpServer {
+    private readonly options;
+    private readonly providers;
+    private readonly store;
+    private readonly supportedProtocolVersions;
+    private readonly resources;
+    private readonly textDecoder;
+    private readonly connections;
+    private readonly activeClientToolCalls;
+    private serverSeq;
+    constructor(options: AhpServerOptions);
+    accept(transport: ServerTransport): Promise<void>;
+    private decode;
+    private decodeText;
+    private handleMessage;
+    private handleRequest;
+    private dispatchRequest;
+    private handleNotification;
+    private initialize;
+    private reconnect;
+    private subscribe;
+    private listSessions;
+    private resolveSessionConfig;
+    private createSession;
+    private disposeSession;
+    private fetchTurns;
+    private dispatchAction;
+    private acceptClientSessionAction;
+    private syncActiveClientTools;
+    private reportActiveClientToolInvocation;
+    private clearActiveClientForConnection;
+    private deleteActiveClientToolCalls;
+    private completeActiveClientToolCall;
+    private queueAgentTurn;
+    private startAgentTurn;
+    private snapshot;
+    private publishRootNotification;
+    private publishRootAction;
+    private applySessionAction;
+    private publishAction;
+    private firstProvider;
+    private requireSession;
+    private isRequest;
+    private isResponse;
+}
+export declare function textMessage(text: string): Message;
+export declare function markdownResponsePart(partId: string): StateAction;
+export declare function completeTurn(turnId: string): StateAction;
+//# sourceMappingURL=server.d.ts.map

package/dist/src/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAYL,KAAK,OAAO,EAiBZ,KAAK,WAAW,EAMjB,MAAM,gCAAgC,CAAC;AAKxC,OAAO,KAAK,EAIV,gBAAgB,EAKhB,eAAe,EAIhB,MAAM,YAAY,CAAC;AAwCpB,qBAAa,SAAS;IAUR,OAAO,CAAC,QAAQ,CAAC,OAAO;IATpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoC;IAC9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAChD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiD;IACvF,OAAO,CAAC,SAAS,CAAK;gBAEO,OAAO,EAAE,gBAAgB;IAWhD,MAAM,CAAC,SAAS,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BvD,OAAO,CAAC,MAAM;IAUd,OAAO,CAAC,UAAU;YAIJ,aAAa;YAWb,aAAa;YASb,eAAe;YA2Cf,kBAAkB;IAehC,OAAO,CAAC,UAAU;IA2BlB,OAAO,CAAC,SAAS;IAajB,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,YAAY;YAIN,oBAAoB;YAcpB,aAAa;YAwEb,cAAc;IAa5B,OAAO,CAAC,UAAU;YAOJ,cAAc;IA0C5B,OAAO,CAAC,yBAAyB;YAkCnB,qBAAqB;IAInC,OAAO,CAAC,gCAAgC;YA6C1B,8BAA8B;IAkB5C,OAAO,CAAC,2BAA2B;IASnC,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,cAAc;YAIR,cAAc;IAwC5B,OAAO,CAAC,QAAQ;IAgBhB,OAAO,CAAC,uBAAuB;IAS/B,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,UAAU;CAGnB;AAwDD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAUhE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAKxD"}

package/dist/src/server.js

@@ -0,0 +1,625 @@
+import { SUPPORTED_PROTOCOL_VERSIONS, rootReducer, sessionReducer, } from '@microsoft/agent-host-protocol';
+import { AhpServerError, JsonRpcErrorCodes, toJsonRpcError } from './errors.js';
+import { FileResourceService } from './resources.js';
+import { InMemorySessionStore } from './store.js';
+const ROOT_URI = 'ahp-root://';
+const ACTION = {
+    RootActiveSessionsChanged: 'root/activeSessionsChanged',
+    SessionReady: 'session/ready',
+    SessionCreationFailed: 'session/creationFailed',
+    SessionTurnStarted: 'session/turnStarted',
+    SessionPendingMessageSet: 'session/pendingMessageSet',
+    SessionTurnCancelled: 'session/turnCancelled',
+    SessionError: 'session/error',
+    SessionResponsePart: 'session/responsePart',
+    SessionTurnComplete: 'session/turnComplete',
+    SessionActiveClientChanged: 'session/activeClientChanged',
+    SessionActiveClientToolsChanged: 'session/activeClientToolsChanged',
+    SessionToolCallStart: 'session/toolCallStart',
+    SessionToolCallReady: 'session/toolCallReady',
+    SessionToolCallComplete: 'session/toolCallComplete',
+    SessionToolCallContentChanged: 'session/toolCallContentChanged',
+    SessionToolCallResultConfirmed: 'session/toolCallResultConfirmed',
+};
+export class AhpServer {
+    options;
+    providers = new Map();
+    store;
+    supportedProtocolVersions;
+    resources;
+    textDecoder = new TextDecoder();
+    connections = new Set();
+    activeClientToolCalls = new Map();
+    serverSeq = 0;
+    constructor(options) {
+        this.options = options;
+        for (const provider of options.providers) {
+            this.providers.set(provider.agent.provider, provider);
+        }
+        this.store = options.store ?? new InMemorySessionStore(options.providers.map(p => p.agent));
+        this.supportedProtocolVersions = [...(options.supportedProtocolVersions ?? SUPPORTED_PROTOCOL_VERSIONS)];
+        this.resources = new FileResourceService({
+            roots: options.resourceRoots ?? (options.defaultDirectory ? [options.defaultDirectory] : undefined),
+        });
+    }
+    async accept(transport) {
+        const connection = {
+            transport,
+            initialized: false,
+            subscriptions: new Set(),
+            send: async (message) => {
+                await transport.send(message);
+            },
+        };
+        this.connections.add(connection);
+        try {
+            while (true) {
+                const inbound = await transport.recv();
+                if (inbound === null) {
+                    return;
+                }
+                const message = this.decode(inbound);
+                await this.handleMessage(connection, message);
+            }
+        }
+        finally {
+            await this.clearActiveClientForConnection(connection);
+            this.connections.delete(connection);
+            await transport.close();
+        }
+    }
+    decode(frame) {
+        if (frame.kind === 'parsed') {
+            return frame.message;
+        }
+        if (frame.kind === 'binary') {
+            return this.decodeText(this.textDecoder.decode(frame.data));
+        }
+        return this.decodeText(frame.text);
+    }
+    decodeText(text) {
+        return JSON.parse(text);
+    }
+    async handleMessage(connection, message) {
+        if (this.isResponse(message)) {
+            return;
+        }
+        if (this.isRequest(message)) {
+            await this.handleRequest(connection, message);
+            return;
+        }
+        await this.handleNotification(connection, message);
+    }
+    async handleRequest(connection, request) {
+        try {
+            const result = await this.dispatchRequest(connection, request.method, request.params);
+            await connection.send({ jsonrpc: '2.0', id: request.id, result });
+        }
+        catch (error) {
+            await connection.send({ jsonrpc: '2.0', id: request.id, error: toJsonRpcError(error) });
+        }
+    }
+    async dispatchRequest(connection, method, params) {
+        switch (method) {
+            case 'initialize':
+                return this.initialize(connection, params);
+            case 'ping':
+                return null;
+            case 'reconnect':
+                return this.reconnect(connection, params);
+            case 'subscribe':
+                return this.subscribe(connection, params);
+            case 'listSessions':
+                return this.listSessions();
+            case 'resourceRead':
+                return this.resources.read(params);
+            case 'resourceWrite':
+                return this.resources.write(params);
+            case 'resourceList':
+                return this.resources.list(params);
+            case 'resourceCopy':
+                return this.resources.copy(params);
+            case 'resourceDelete':
+                return this.resources.delete(params);
+            case 'resourceMove':
+                return this.resources.move(params);
+            case 'resourceResolve':
+                return this.resources.resolve(params);
+            case 'resourceMkdir':
+                return this.resources.mkdir(params);
+            case 'resolveSessionConfig':
+                return this.resolveSessionConfig(params);
+            case 'createSession':
+                return this.createSession(connection, params);
+            case 'disposeSession':
+                return this.disposeSession(params);
+            case 'fetchTurns':
+                return this.fetchTurns(params);
+            case 'completions':
+                return { items: [] };
+            default:
+                throw new AhpServerError(JsonRpcErrorCodes.MethodNotFound, `method not found: ${method}`);
+        }
+    }
+    async handleNotification(connection, notification) {
+        switch (notification.method) {
+            case 'unsubscribe': {
+                const { channel } = notification.params;
+                connection.subscriptions.delete(channel);
+                return;
+            }
+            case 'dispatchAction':
+                await this.dispatchAction(connection, notification.params);
+                return;
+            default:
+                return;
+        }
+    }
+    initialize(connection, params) {
+        const protocolVersion = params.protocolVersions.find(version => this.supportedProtocolVersions.includes(version));
+        if (!protocolVersion) {
+            throw new AhpServerError(JsonRpcErrorCodes.UnsupportedProtocolVersion, `unsupported protocol versions: ${params.protocolVersions.join(', ')}`);
+        }
+        connection.clientId = params.clientId;
+        connection.initialized = true;
+        const snapshots = (params.initialSubscriptions ?? []).map(uri => {
+            connection.subscriptions.add(uri);
+            return this.snapshot(uri);
+        });
+        return {
+            protocolVersion,
+            serverSeq: this.serverSeq,
+            snapshots,
+            ...(this.options.defaultDirectory ? { defaultDirectory: this.options.defaultDirectory } : {}),
+        };
+    }
+    reconnect(connection, params) {
+        connection.clientId = params.clientId;
+        connection.initialized = true;
+        connection.subscriptions.clear();
+        for (const uri of params.subscriptions) {
+            connection.subscriptions.add(uri);
+        }
+        return {
+            type: 'snapshot',
+            snapshots: params.subscriptions.map(uri => this.snapshot(uri)),
+        };
+    }
+    subscribe(connection, params) {
+        connection.subscriptions.add(params.channel);
+        return { snapshot: this.snapshot(params.channel) };
+    }
+    listSessions() {
+        return { items: this.store.listSessions() };
+    }
+    async resolveSessionConfig(params) {
+        const provider = params.provider ? this.providers.get(params.provider) : this.firstProvider();
+        if (!provider) {
+            throw new AhpServerError(JsonRpcErrorCodes.ProviderNotFound, `provider not found: ${params.provider ?? '(default)'}`);
+        }
+        if (!provider.resolveSessionConfig) {
+            return { schema: { type: 'object', properties: {} }, values: params.config ?? {} };
+        }
+        return provider.resolveSessionConfig({
+            workingDirectory: params.workingDirectory,
+            config: params.config,
+        });
+    }
+    async createSession(connection, params) {
+        if (this.store.getSession(params.channel)) {
+            throw new AhpServerError(JsonRpcErrorCodes.SessionAlreadyExists, `session already exists: ${params.channel}`);
+        }
+        const provider = params.provider ? this.providers.get(params.provider) : this.firstProvider();
+        if (!provider) {
+            throw new AhpServerError(JsonRpcErrorCodes.ProviderNotFound, `provider not found: ${params.provider ?? '(default)'}`);
+        }
+        if (params.activeClient && params.activeClient.clientId !== connection.clientId) {
+            throw new AhpServerError(JsonRpcErrorCodes.PermissionDenied, 'active client must match initialized client id');
+        }
+        const now = Date.now();
+        const state = {
+            summary: {
+                resource: params.channel,
+                provider: provider.agent.provider,
+                title: 'New Session',
+                status: 1,
+                createdAt: now,
+                modifiedAt: now,
+                ...(params.model ? { model: params.model } : {}),
+                ...(params.agent ? { agent: params.agent } : {}),
+                ...(params.workingDirectory ? { workingDirectory: params.workingDirectory } : {}),
+            },
+            lifecycle: 'creating',
+            turns: [],
+            ...(params.config ? {
+                config: {
+                    schema: { type: 'object', properties: {} },
+                    values: params.config,
+                },
+            } : {}),
+            ...(params.activeClient ? { activeClient: params.activeClient } : {}),
+        };
+        const stored = { uri: params.channel, state };
+        this.store.addSession(stored);
+        this.publishRootNotification('root/sessionAdded', { channel: ROOT_URI, summary: state.summary });
+        this.publishRootAction({ type: ACTION.RootActiveSessionsChanged, activeSessions: this.store.listSessions().length });
+        try {
+            stored.agentSession = await provider.createSession({
+                sessionUri: params.channel,
+                providerId: provider.agent.provider,
+                workingDirectory: params.workingDirectory,
+                model: params.model,
+                config: params.config,
+                activeClientId: connection.clientId,
+                activeClientTools: activeClientToolsFromState(state),
+                activeClientToolSink: {
+                    reportInvocation: invocation => {
+                        return this.reportActiveClientToolInvocation(params.channel, invocation);
+                    },
+                },
+            });
+            await this.syncActiveClientTools(stored);
+            this.applySessionAction(params.channel, { type: ACTION.SessionReady });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.applySessionAction(params.channel, {
+                type: ACTION.SessionCreationFailed,
+                error: { errorType: 'provider.createSession', message },
+            });
+            throw new AhpServerError(JsonRpcErrorCodes.InternalError, `provider.createSession failed: ${message}`);
+        }
+        return null;
+    }
+    async disposeSession(params) {
+        const session = this.store.removeSession(params.channel);
+        if (!session) {
+            throw new AhpServerError(JsonRpcErrorCodes.NotFound, `session not found: ${params.channel}`);
+        }
+        session.abortController?.abort();
+        await session.agentSession?.dispose?.();
+        this.deleteActiveClientToolCalls(params.channel);
+        this.publishRootNotification('root/sessionRemoved', { channel: ROOT_URI, session: params.channel });
+        this.publishRootAction({ type: ACTION.RootActiveSessionsChanged, activeSessions: this.store.listSessions().length });
+        return null;
+    }
+    fetchTurns(params) {
+        const session = this.requireSession(params.channel);
+        const turns = session.state.turns;
+        const limit = params.limit ?? turns.length;
+        return { turns: turns.slice(Math.max(0, turns.length - limit)), hasMore: false };
+    }
+    async dispatchAction(connection, params) {
+        const origin = connection.clientId
+            ? { clientId: connection.clientId, clientSeq: params.clientSeq }
+            : undefined;
+        if (params.channel === ROOT_URI) {
+            this.publishRootAction(params.action, origin);
+            return;
+        }
+        const session = this.requireSession(params.channel);
+        if (!this.acceptClientSessionAction(connection, session, params.action)) {
+            return;
+        }
+        this.applySessionAction(params.channel, params.action, origin);
+        if (params.action.type === ACTION.SessionTurnStarted) {
+            this.queueAgentTurn(session, params.action.turnId, params.action.message);
+        }
+        else if (params.action.type === ACTION.SessionPendingMessageSet) {
+            this.queueAgentTurn(session, params.action.id, params.action.message);
+        }
+        else if (params.action.type === ACTION.SessionTurnCancelled) {
+            session.abortController?.abort(params.action.turnId);
+            await session.agentSession?.cancel?.(params.action.turnId);
+        }
+        else if (params.action.type === ACTION.SessionActiveClientChanged ||
+            params.action.type === ACTION.SessionActiveClientToolsChanged) {
+            if (params.action.type === ACTION.SessionActiveClientChanged && !params.action.activeClient) {
+                this.deleteActiveClientToolCalls(params.channel);
+            }
+            await this.syncActiveClientTools(session);
+        }
+        else if (params.action.type === ACTION.SessionToolCallComplete &&
+            !params.action.requiresResultConfirmation) {
+            this.completeActiveClientToolCall(params.channel, params.action.toolCallId, params.action.result);
+        }
+        else if (params.action.type === ACTION.SessionToolCallResultConfirmed) {
+            this.activeClientToolCalls.delete(activeClientToolCallKey(params.channel, params.action.toolCallId));
+        }
+    }
+    acceptClientSessionAction(connection, session, action) {
+        if (action.type === ACTION.SessionActiveClientChanged) {
+            const currentClientId = session.state.activeClient?.clientId;
+            const requestedClientId = action.activeClient?.clientId;
+            if (!connection.clientId) {
+                return false;
+            }
+            if (requestedClientId && requestedClientId !== connection.clientId) {
+                return false;
+            }
+            if (currentClientId && currentClientId !== connection.clientId) {
+                return false;
+            }
+            return true;
+        }
+        if (action.type === ACTION.SessionActiveClientToolsChanged) {
+            return Boolean(connection.clientId && session.state.activeClient?.clientId === connection.clientId);
+        }
+        if (isClientToolResultAction(action)) {
+            const record = this.activeClientToolCalls.get(activeClientToolCallKey(session.uri, action.toolCallId));
+            if (!record) {
+                if (clientContributorFromSessionState(session.state, action.toolCallId)) {
+                    return false;
+                }
+                return true;
+            }
+            return connection.clientId === record.clientId && session.state.activeClient?.clientId === record.clientId;
+        }
+        return true;
+    }
+    async syncActiveClientTools(session) {
+        await session.agentSession?.setActiveClientTools?.(activeClientToolsFromState(session.state));
+    }
+    reportActiveClientToolInvocation(sessionUri, invocation) {
+        const session = this.store.getSession(sessionUri);
+        const activeClient = session?.state.activeClient;
+        if (!session || !activeClient) {
+            throw new Error(`session has no active client: ${sessionUri}`);
+        }
+        const tool = activeClient.tools.find(candidate => candidate.name === invocation.toolName);
+        if (!tool) {
+            throw new Error(`active client tool not found: ${invocation.toolName}`);
+        }
+        const completion = new Promise((resolve, reject) => {
+            this.activeClientToolCalls.set(activeClientToolCallKey(sessionUri, invocation.toolCallId), {
+                sessionUri,
+                turnId: invocation.turnId,
+                toolCallId: invocation.toolCallId,
+                toolName: invocation.toolName,
+                clientId: activeClient.clientId,
+                resolve,
+                reject,
+            });
+        });
+        const displayName = invocation.displayName ?? tool.title ?? tool.name;
+        this.applySessionAction(sessionUri, {
+            type: ACTION.SessionToolCallStart,
+            turnId: invocation.turnId,
+            toolCallId: invocation.toolCallId,
+            toolName: invocation.toolName,
+            displayName,
+            contributor: { kind: 'client', clientId: activeClient.clientId },
+            ...(invocation._meta ? { _meta: invocation._meta } : {}),
+        });
+        this.applySessionAction(sessionUri, {
+            type: ACTION.SessionToolCallReady,
+            turnId: invocation.turnId,
+            toolCallId: invocation.toolCallId,
+            invocationMessage: invocation.invocationMessage ?? displayName,
+            ...(invocation.toolInput ? { toolInput: invocation.toolInput } : {}),
+            confirmed: 'not-needed',
+            ...(invocation._meta ? { _meta: invocation._meta } : {}),
+        });
+        return completion;
+    }
+    async clearActiveClientForConnection(connection) {
+        if (!connection.clientId) {
+            return;
+        }
+        for (const summary of this.store.listSessions()) {
+            const session = this.store.getSession(summary.resource);
+            if (!session || session.state.activeClient?.clientId !== connection.clientId) {
+                continue;
+            }
+            this.applySessionAction(session.uri, {
+                type: ACTION.SessionActiveClientChanged,
+                activeClient: null,
+            });
+            this.deleteActiveClientToolCalls(session.uri);
+            await this.syncActiveClientTools(session);
+        }
+    }
+    deleteActiveClientToolCalls(sessionUri) {
+        for (const [key, record] of this.activeClientToolCalls.entries()) {
+            if (record.sessionUri === sessionUri) {
+                this.activeClientToolCalls.delete(key);
+                record.reject(new Error(`active client tool call cancelled for session ${sessionUri}`));
+            }
+        }
+    }
+    completeActiveClientToolCall(sessionUri, toolCallId, result) {
+        const key = activeClientToolCallKey(sessionUri, toolCallId);
+        const record = this.activeClientToolCalls.get(key);
+        if (!record) {
+            return;
+        }
+        this.activeClientToolCalls.delete(key);
+        record.resolve(result);
+    }
+    queueAgentTurn(session, turnId, message) {
+        void this.startAgentTurn(session, turnId, message);
+    }
+    async startAgentTurn(session, turnId, message) {
+        if (!session.agentSession) {
+            this.applySessionAction(session.uri, {
+                type: ACTION.SessionError,
+                turnId,
+                error: { errorType: 'session.notReady', message: 'session backend is not ready' },
+            });
+            return;
+        }
+        session.abortController?.abort('new turn started');
+        const abortController = new AbortController();
+        session.abortController = abortController;
+        const sink = {
+            emit: action => this.applySessionAction(session.uri, action),
+            fail: error => {
+                this.applySessionAction(session.uri, {
+                    type: ACTION.SessionError,
+                    turnId,
+                    error: { errorType: 'agent.turn', message: error.message },
+                });
+            },
+        };
+        try {
+            await session.agentSession.sendUserMessage(message, sink, abortController.signal, turnId);
+        }
+        catch (error) {
+            if (abortController.signal.aborted) {
+                return;
+            }
+            const messageText = error instanceof Error ? error.message : String(error);
+            this.applySessionAction(session.uri, {
+                type: ACTION.SessionError,
+                turnId,
+                error: { errorType: 'agent.turn', message: messageText },
+            });
+        }
+    }
+    snapshot(uri) {
+        if (uri === ROOT_URI) {
+            return {
+                resource: ROOT_URI,
+                state: this.store.getRootState(),
+                fromSeq: this.serverSeq,
+            };
+        }
+        const session = this.requireSession(uri);
+        return {
+            resource: uri,
+            state: session.state,
+            fromSeq: this.serverSeq,
+        };
+    }
+    publishRootNotification(method, params) {
+        const notification = { jsonrpc: '2.0', method, params };
+        for (const connection of this.connections) {
+            if (connection.subscriptions.has(ROOT_URI)) {
+                void connection.send(notification);
+            }
+        }
+    }
+    publishRootAction(action, origin) {
+        const root = this.store.getRootState();
+        const updated = rootReducer(root, action);
+        if ('setAgents' in this.store && typeof this.store.setAgents === 'function') {
+            this.store.setAgents(updated.agents);
+        }
+        this.publishAction(ROOT_URI, action, origin);
+    }
+    applySessionAction(uri, action, origin) {
+        const session = this.store.updateSession(uri, stored => {
+            stored.state = sessionReducer(stored.state, action);
+            stored.state.summary.modifiedAt = Date.now();
+        });
+        this.publishAction(uri, action, origin);
+        this.publishRootNotification('root/sessionSummaryChanged', {
+            channel: ROOT_URI,
+            session: uri,
+            changes: session.state.summary,
+        });
+    }
+    publishAction(channel, action, origin) {
+        const envelope = {
+            channel,
+            action,
+            serverSeq: ++this.serverSeq,
+            origin,
+        };
+        const notification = {
+            jsonrpc: '2.0',
+            method: 'action',
+            params: envelope,
+        };
+        for (const connection of this.connections) {
+            if (connection.subscriptions.has(channel)) {
+                void connection.send(notification);
+            }
+        }
+    }
+    firstProvider() {
+        return this.providers.values().next().value;
+    }
+    requireSession(uri) {
+        const session = this.store.getSession(uri);
+        if (!session) {
+            throw new AhpServerError(JsonRpcErrorCodes.NotFound, `session not found: ${uri}`);
+        }
+        return session;
+    }
+    isRequest(message) {
+        return 'method' in message && 'id' in message;
+    }
+    isResponse(message) {
+        return 'id' in message && ('result' in message || 'error' in message) && !('method' in message);
+    }
+}
+function activeClientToolsFromState(state) {
+    return state.activeClient
+        ? { clientId: state.activeClient.clientId, tools: state.activeClient.tools }
+        : undefined;
+}
+function isClientToolResultAction(action) {
+    return action.type === ACTION.SessionToolCallComplete ||
+        action.type === ACTION.SessionToolCallContentChanged ||
+        action.type === ACTION.SessionToolCallResultConfirmed;
+}
+function activeClientToolCallKey(sessionUri, toolCallId) {
+    return `${sessionUri}\u0000${toolCallId}`;
+}
+function clientContributorFromSessionState(state, toolCallId) {
+    for (const part of responsePartsFromSessionState(state)) {
+        if (!isRecord(part) || part.kind !== 'toolCall' || !isRecord(part.toolCall)) {
+            continue;
+        }
+        const toolCall = part.toolCall;
+        if (toolCall.toolCallId !== toolCallId || !isRecord(toolCall.contributor)) {
+            continue;
+        }
+        const contributor = toolCall.contributor;
+        if (contributor.kind === 'client' && typeof contributor.clientId === 'string') {
+            return contributor.clientId;
+        }
+    }
+    return undefined;
+}
+function responsePartsFromSessionState(state) {
+    const parts = [];
+    const stateRecord = state;
+    const activeTurn = stateRecord.activeTurn;
+    if (isRecord(activeTurn) && Array.isArray(activeTurn.responseParts)) {
+        parts.push(...activeTurn.responseParts);
+    }
+    if (Array.isArray(stateRecord.turns)) {
+        for (const turn of stateRecord.turns) {
+            if (isRecord(turn) && Array.isArray(turn.responseParts)) {
+                parts.push(...turn.responseParts);
+            }
+        }
+    }
+    return parts;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function textMessage(text) {
+    return { text, origin: { kind: 'user' } };
+}
+export function markdownResponsePart(partId) {
+    return {
+        type: ACTION.SessionResponsePart,
+        turnId: partId.split(':')[0] ?? partId,
+        part: {
+            kind: 'markdown',
+            id: partId,
+            content: '',
+        },
+    };
+}
+export function completeTurn(turnId) {
+    return {
+        type: ACTION.SessionTurnComplete,
+        turnId,
+    };
+}
+//# sourceMappingURL=server.js.map