@getpaseo/server 0.1.98 → 0.1.100

package/dist/server/server/session/agent-config/agent-config-session.d.ts

@@ -0,0 +1,50 @@
+import type pino from "pino";
+import type { AgentProviderNotice } from "../../agent/agent-sdk-types.js";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+export interface AgentConfigSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+}
+/**
+ * The per-agent config mutations this subsystem drives. The shell adapts these
+ * onto the live AgentManager (mode still routes through setAgentModeCommand);
+ * tests wire an in-memory fake. Mode and thinking yield a provider notice; model
+ * and feature do not.
+ */
+export interface AgentConfigOperations {
+    setMode(agentId: string, modeId: string): Promise<AgentProviderNotice | null>;
+    setModel(agentId: string, modelId: string | null): Promise<void>;
+    setFeature(agentId: string, featureId: string, value: unknown): Promise<void>;
+    setThinking(agentId: string, thinkingOptionId: string | null): Promise<AgentProviderNotice | null>;
+}
+export interface AgentConfigSessionOptions {
+    host: AgentConfigSessionHost;
+    operations: AgentConfigOperations;
+    logger: pino.Logger;
+}
+/**
+ * A client's per-agent config surface: set mode, model, feature, and thinking
+ * option. Each request shares one envelope — log, run the mutation, then emit the
+ * accepted response, or on failure emit an activity_log error frame followed by
+ * the rejected response. Reaches no state beyond the injected operations and the
+ * outbound channel.
+ */
+export declare class AgentConfigSession {
+    private readonly host;
+    private readonly operations;
+    private readonly logger;
+    constructor(options: AgentConfigSessionOptions);
+    handleSetAgentModeRequest(msg: Extract<SessionInboundMessage, {
+        type: "set_agent_mode_request";
+    }>): Promise<void>;
+    handleSetAgentModelRequest(msg: Extract<SessionInboundMessage, {
+        type: "set_agent_model_request";
+    }>): Promise<void>;
+    handleSetAgentFeatureRequest(msg: Extract<SessionInboundMessage, {
+        type: "set_agent_feature_request";
+    }>): Promise<void>;
+    handleSetAgentThinkingRequest(msg: Extract<SessionInboundMessage, {
+        type: "set_agent_thinking_request";
+    }>): Promise<void>;
+    private applyConfigChange;
+}
+//# sourceMappingURL=agent-config-session.d.ts.map

package/dist/server/server/session/agent-config/agent-config-session.js

@@ -0,0 +1,98 @@
+import { v4 as uuidv4 } from "uuid";
+import { getErrorMessage, getErrorMessageOr } from "@getpaseo/protocol/error-utils";
+/**
+ * A client's per-agent config surface: set mode, model, feature, and thinking
+ * option. Each request shares one envelope — log, run the mutation, then emit the
+ * accepted response, or on failure emit an activity_log error frame followed by
+ * the rejected response. Reaches no state beyond the injected operations and the
+ * outbound channel.
+ */
+export class AgentConfigSession {
+    constructor(options) {
+        this.host = options.host;
+        this.operations = options.operations;
+        this.logger = options.logger;
+    }
+    handleSetAgentModeRequest(msg) {
+        const { agentId, modeId, requestId } = msg;
+        return this.applyConfigChange({
+            agentId,
+            requestId,
+            logLabel: "set_agent_mode_request",
+            logFields: { agentId, modeId, requestId },
+            failureText: "Failed to set agent mode",
+            run: () => this.operations.setMode(agentId, modeId),
+            emitResponse: (payload) => this.host.emit({ type: "set_agent_mode_response", payload }),
+        });
+    }
+    handleSetAgentModelRequest(msg) {
+        const { agentId, modelId, requestId } = msg;
+        return this.applyConfigChange({
+            agentId,
+            requestId,
+            logLabel: "set_agent_model_request",
+            logFields: { agentId, modelId, requestId },
+            failureText: "Failed to set agent model",
+            run: async () => {
+                await this.operations.setModel(agentId, modelId);
+                return undefined;
+            },
+            emitResponse: (payload) => this.host.emit({ type: "set_agent_model_response", payload }),
+        });
+    }
+    handleSetAgentFeatureRequest(msg) {
+        const { agentId, featureId, value, requestId } = msg;
+        return this.applyConfigChange({
+            agentId,
+            requestId,
+            logLabel: "set_agent_feature_request",
+            logFields: { agentId, featureId, value, requestId },
+            failureText: "Failed to set agent feature",
+            run: async () => {
+                await this.operations.setFeature(agentId, featureId, value);
+                return undefined;
+            },
+            emitResponse: (payload) => this.host.emit({ type: "set_agent_feature_response", payload }),
+        });
+    }
+    handleSetAgentThinkingRequest(msg) {
+        const { agentId, thinkingOptionId, requestId } = msg;
+        return this.applyConfigChange({
+            agentId,
+            requestId,
+            logLabel: "set_agent_thinking_request",
+            logFields: { agentId, thinkingOptionId, requestId },
+            failureText: "Failed to set agent thinking option",
+            run: () => this.operations.setThinking(agentId, thinkingOptionId),
+            emitResponse: (payload) => this.host.emit({ type: "set_agent_thinking_response", payload }),
+        });
+    }
+    async applyConfigChange(change) {
+        const { agentId, requestId, logLabel, logFields, failureText, run, emitResponse } = change;
+        this.logger.info(logFields, `session: ${logLabel}`);
+        try {
+            const notice = await run();
+            this.logger.info(logFields, `session: ${logLabel} success`);
+            emitResponse({ requestId, agentId, accepted: true, error: null, notice });
+        }
+        catch (error) {
+            this.logger.error({ err: error, ...logFields }, `session: ${logLabel} error`);
+            this.host.emit({
+                type: "activity_log",
+                payload: {
+                    id: uuidv4(),
+                    timestamp: new Date(),
+                    type: "error",
+                    content: `${failureText}: ${getErrorMessage(error)}`,
+                },
+            });
+            emitResponse({
+                requestId,
+                agentId,
+                accepted: false,
+                error: getErrorMessageOr(error, failureText),
+            });
+        }
+    }
+}
+//# sourceMappingURL=agent-config-session.js.map

package/dist/server/server/session/chat/chat-schedule-loop-session.d.ts

@@ -0,0 +1,120 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { StoredAgentRecord } from "../../agent/agent-storage.js";
+import type { ManagedAgent } from "../../agent/agent-manager.js";
+import { type FileBackedChatService } from "../../chat/chat-service.js";
+import type { LoopService } from "../../loop-service.js";
+import type { ScheduleService } from "../../schedule/service.js";
+/**
+ * The collaborators a chat command reaches that are NOT part of the chat/schedule/loop
+ * domain: the agent roster reads and the agent-message send used only by chat/post
+ * mention fanout. The Session shell owns the agent lifecycle; this subsystem orchestrates
+ * a notification through it but does not own it.
+ */
+export interface ChatScheduleLoopSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+    listStoredAgents(): Promise<StoredAgentRecord[]>;
+    listLiveAgents(): ManagedAgent[];
+    resolveAgentIdentifier(identifier: string): Promise<{
+        ok: true;
+        agentId: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    sendAgentMessage(agentId: string, text: string): Promise<void>;
+}
+export interface ChatScheduleLoopSessionOptions {
+    host: ChatScheduleLoopSessionHost;
+    chatService: FileBackedChatService;
+    scheduleService: ScheduleService;
+    loopService: LoopService;
+    clientId: string;
+    logger: pino.Logger;
+}
+/**
+ * A client's chat, schedule, and loop request surface. The three families are the
+ * least-coupled in the session: each is a stateless request/response over its own
+ * service (chat rooms, cron routines, autonomous loops), with no shared observer,
+ * git, or voice state and no subscriptions to tear down. They live in one subsystem
+ * because they are dispatched together — schedule/* was historically reached through
+ * the chat dispatcher's fall-through arm. The three rpc-error emitters stay separate:
+ * they differ by default code, and only the chat one reads ChatServiceError.code.
+ */
+export declare class ChatScheduleLoopSession {
+    private readonly host;
+    private readonly chatService;
+    private readonly scheduleService;
+    private readonly loopService;
+    private readonly clientId;
+    private readonly logger;
+    constructor(options: ChatScheduleLoopSessionOptions);
+    private emitChatRpcError;
+    handleChatCreateRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/create";
+    }>): Promise<void>;
+    handleChatListRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/list";
+    }>): Promise<void>;
+    handleChatInspectRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/inspect";
+    }>): Promise<void>;
+    handleChatDeleteRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/delete";
+    }>): Promise<void>;
+    handleChatPostRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/post";
+    }>): Promise<void>;
+    handleChatReadRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/read";
+    }>): Promise<void>;
+    handleChatWaitRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/wait";
+    }>): Promise<void>;
+    private toScheduleSummary;
+    private emitScheduleRpcError;
+    handleScheduleCreateRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/create";
+    }>): Promise<void>;
+    handleScheduleListRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/list";
+    }>): Promise<void>;
+    handleScheduleInspectRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/inspect";
+    }>): Promise<void>;
+    handleScheduleLogsRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/logs";
+    }>): Promise<void>;
+    handleSchedulePauseRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/pause";
+    }>): Promise<void>;
+    handleScheduleResumeRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/resume";
+    }>): Promise<void>;
+    handleScheduleDeleteRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/delete";
+    }>): Promise<void>;
+    handleScheduleRunOnceRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/run-once";
+    }>): Promise<void>;
+    handleScheduleUpdateRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/update";
+    }>): Promise<void>;
+    private emitLoopRpcError;
+    handleLoopRunRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/run";
+    }>): Promise<void>;
+    handleLoopListRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/list";
+    }>): Promise<void>;
+    handleLoopInspectRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/inspect";
+    }>): Promise<void>;
+    handleLoopLogsRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/logs";
+    }>): Promise<void>;
+    handleLoopStopRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/stop";
+    }>): Promise<void>;
+}
+//# sourceMappingURL=chat-schedule-loop-session.d.ts.map