clementine-agent 1.18.44 → 1.18.45

package/dist/agent/assistant.d.ts

@@ -277,6 +277,13 @@ export declare class PersonalAssistant {
     private memoryExtractionKey;
     private assessMemoryExtraction;
     private logMemoryExtractionSkip;
+    /**
+     * Public entry point for triggering auto-memory extraction after an
+     * exchange. Used by the new runAgent chat path (Phase 2 migration)
+     * so it can keep the existing memory-extraction behavior without
+     * having to recreate the surrounding plumbing.
+     */
+    triggerMemoryExtractionPostExchange(userMessage: string, assistantResponse: string, sessionKey?: string, profile?: AgentProfile): Promise<void>;
     private spawnMemoryExtraction;
     private static readonly MEMORY_TOOL_NAMES;
     private extractMemory;

package/dist/agent/assistant.js

@@ -4883,6 +4883,15 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         }
         catch { /* telemetry only */ }
     }
+    /**
+     * Public entry point for triggering auto-memory extraction after an
+     * exchange. Used by the new runAgent chat path (Phase 2 migration)
+     * so it can keep the existing memory-extraction behavior without
+     * having to recreate the surrounding plumbing.
+     */
+    async triggerMemoryExtractionPostExchange(userMessage, assistantResponse, sessionKey, profile) {
+        return this.spawnMemoryExtraction(userMessage, assistantResponse, sessionKey, profile);
+    }
     async spawnMemoryExtraction(userMessage, assistantResponse, sessionKey, profile) {
         // Guard: skip memory extraction if the user message looks like injection
         const memScan = scanner.scan(userMessage);

package/dist/agent/run-agent.d.ts

@@ -66,6 +66,17 @@ export interface RunAgentOptions {
     allowedTools?: string[];
     /** Optional CLAUDE.md / project setting source. Defaults to ['project']. */
     settingSources?: ('project' | 'user' | 'local')[];
+    /** Additional MCP servers to merge with the always-on clementine-tools
+     *  server. Use to wire Composio + claude.ai integrations on chat-path
+     *  invocations that need Outlook/Salesforce/etc. */
+    extraMcpServers?: Record<string, {
+        type: 'stdio' | 'http' | 'sse';
+        command?: string;
+        args?: string[];
+        env?: Record<string, string>;
+        url?: string;
+        headers?: Record<string, string>;
+    }>;
 }
 export interface RunAgentResult {
     /** Final text response from the agent. */

package/dist/agent/run-agent.js

@@ -124,6 +124,9 @@ export async function runAgent(prompt, opts) {
     // list references mcp__clementine-tools__* that don't exist in the
     // session, and the agent falls back to reading raw JSON files.
     const subprocessEnv = buildRunAgentEnv();
+    // SDK accepts a Record<string, McpServerConfig> here. We cast on
+    // assignment because we mix the always-on Clementine stdio server
+    // with caller-supplied servers of various types.
     const mcpServers = {
         [TOOLS_SERVER]: {
             type: 'stdio',
@@ -136,6 +139,7 @@ export async function runAgent(prompt, opts) {
                 CLEMENTINE_INTERACTION_SOURCE: source === 'cron' || source === 'heartbeat' ? 'autonomous' : 'interactive',
             },
         },
+        ...(opts.extraMcpServers ?? {}),
     };
     // Apply 1M-context env normalization (existing infra)
     const sdkOptionsRaw = {
@@ -144,7 +148,9 @@ export async function runAgent(prompt, opts) {
             : { type: 'preset', preset: 'claude_code' },
         settingSources: opts.settingSources ?? ['project'],
         agents,
-        mcpServers,
+        // SDK's McpServerConfig is a union; cast at the boundary since
+        // callers can mix stdio + http + sse server shapes.
+        mcpServers: mcpServers,
         allowedTools,
         permissionMode: 'bypassPermissions',
         cwd: BASE_DIR,

package/dist/gateway/router.js

@@ -2088,6 +2088,79 @@ export class Gateway {
                     delete sessState.pendingInterrupt;
                 }
                 try {
+                    // ── Phase 2: opt-in canonical SDK chat path ──────────────────
+                    // When CLEMENTINE_USE_RUNAGENT_CHAT=1 is set, route through
+                    // the new runAgent() wrapper instead of the legacy
+                    // assistant.chat path. This is the SDK-canonical pattern
+                    // (one query() call, agents map for subagents, no
+                    // wrapper layers). Today's Phase 2 connects only the
+                    // Clementine MCP server — Composio/external integrations
+                    // come in Phase 3. Useful for testing the new path on
+                    // tool-light sessions like cron-fix or memory queries.
+                    //
+                    // The legacy path (default) keeps full Composio/external
+                    // routing + all post-response handlers, so this flag is
+                    // safe to leave off until we're ready.
+                    if (process.env.CLEMENTINE_USE_RUNAGENT_CHAT === '1'
+                        && this.isTrustedPersonalSession(sessionKey)
+                        && !sessState.pendingInterrupt) {
+                        const { runAgent } = await import('../agent/run-agent.js');
+                        logger.info({
+                            sessionKey: effectiveSessionKey,
+                            profile: resolvedProfile?.slug,
+                            path: 'runagent_chat',
+                        }, 'Phase 2: routing chat through runAgent');
+                        try {
+                            const runAgentResult = await runAgent(originalText, {
+                                sessionKey: effectiveSessionKey,
+                                source: 'chat',
+                                profile: resolvedProfile,
+                                agentManager: this.getAgentManager(),
+                                memoryStore: this.assistant.getMemoryStore?.() ?? null,
+                                onText: wrappedOnText,
+                                onToolActivity: ({ tool, input }) => {
+                                    toolActivityCount++;
+                                    if (wrappedOnToolActivity) {
+                                        return wrappedOnToolActivity(tool, input);
+                                    }
+                                    return undefined;
+                                },
+                                abortSignal: chatAc.signal,
+                            });
+                            clearTimeout(chatTimer);
+                            clearTimeout(hardWallTimer);
+                            // Mirror transcript so memory + recall continue working.
+                            const memoryStore = this.assistant.getMemoryStore?.();
+                            if (memoryStore) {
+                                try {
+                                    memoryStore.saveTurn(effectiveSessionKey, 'user', originalText);
+                                    memoryStore.saveTurn(effectiveSessionKey, 'assistant', runAgentResult.text);
+                                }
+                                catch (err) {
+                                    logger.debug({ err }, 'runAgent chat: transcript mirror failed (non-fatal)');
+                                }
+                            }
+                            // Fire auto-memory extraction in the background so
+                            // MEMORY.md continues to update like the legacy path.
+                            this.assistant
+                                .triggerMemoryExtractionPostExchange(originalText, runAgentResult.text, effectiveSessionKey, resolvedProfile)
+                                .catch(err => logger.debug({ err, sessionKey: effectiveSessionKey }, 'runAgent chat: auto-memory failed (non-fatal)'));
+                            logger.info({
+                                sessionKey: effectiveSessionKey,
+                                totalMs: Date.now() - tInnerStart,
+                                routedVia: 'runagent_chat',
+                                numTurns: runAgentResult.numTurns,
+                                cost: Number(runAgentResult.totalCostUsd.toFixed(4)),
+                                responseLen: runAgentResult.text.length,
+                            }, 'chat:latency');
+                            return runAgentResult.text;
+                        }
+                        catch (err) {
+                            logger.warn({ err, sessionKey: effectiveSessionKey }, 'runAgent chat path failed — falling back to legacy chat');
+                            // Fall through to the legacy chat path so the user
+                            // still gets a response.
+                        }
+                    }
                     // ── Pre-LLM plan routing (Gap #3 from orchestration audit) ──
                     // When the user's text clearly maps to multi-step parallel
                     // work, route through the orchestrator BEFORE the main agent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.44",
+  "version": "1.18.45",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",