om-memory-system 3.1.0-next.4 → 3.2.0-next.10

package/dist/services/ai/opencode-provider.js

@@ -60,6 +60,11 @@ export function setHostFetch(customFetch) {
 export function resetHostFetch() {
     _hostFetch = undefined;
 }
+/** Test helper: forget the server URL, as in the native V2 plugin. */
+export function resetV2BaseUrlForTests() {
+    _v2BaseUrl = undefined;
+    _useSdkTransport = false;
+}
 export function setConnectedProviders(providers) {
     _connectedProviders = new Set(providers);
 }
@@ -117,6 +122,22 @@ function sessionPromptFields(args) {
         },
     };
 }
+function reportReply(onReply, data) {
+    if (!onReply)
+        return;
+    try {
+        onReply({
+            ...(typeof data.info.finish === "string" ? { finish: data.info.finish } : {}),
+            partTypes: (Array.isArray(data.parts) ? data.parts : [])
+                .map((part) => typeof part === "object" && part !== null ? part.type : undefined)
+                .filter((type) => typeof type === "string"),
+            structuredOutput: data.info.structured_output ?? data.info.structured,
+        });
+    }
+    catch {
+        // Diagnostics must never change the call's result.
+    }
+}
 /**
  * Resolve `opencodeModel: "inherit"` to a concrete provider/model.
  *
@@ -167,10 +188,12 @@ export async function generateStructuredOutput(opts) {
         providerID: opts.providerID,
         modelID: opts.modelID,
     });
-    const { client, systemPrompt, userPrompt, schema, directory, retryCount } = opts;
+    const { client, systemPrompt, userPrompt, schema, directory, retryCount, onReply } = opts;
     const { providerID, modelID } = resolved;
     const jsonSchema = schema.toJSONSchema?.() ?? (await import("zod")).z.toJSONSchema(schema);
-    if (_useSdkTransport && hasV2SessionClient(client)) {
+    // The native V2 plugin has no server URL: it hands over a client whose
+    // session API wraps the plugin context, so that client is the only transport.
+    if ((_useSdkTransport || !_v2BaseUrl) && hasV2SessionClient(client)) {
         return generateViaSdkClient(client, {
             providerID,
             modelID,
@@ -180,6 +203,7 @@ export async function generateStructuredOutput(opts) {
             retryCount,
             jsonSchema,
             schema,
+            onReply,
         });
     }
     const baseUrl = _v2BaseUrl;
@@ -190,7 +214,7 @@ export async function generateStructuredOutput(opts) {
     const sessionID = await createSession(base, directory);
     markInternalSession(sessionID);
     try {
-        const info = await withStructuredOutputTimeout(() => promptSession(base, {
+        const reply = await withStructuredOutputTimeout(() => promptSession(base, {
             sessionID,
             directory,
             providerID,
@@ -200,6 +224,8 @@ export async function generateStructuredOutput(opts) {
             jsonSchema,
             retryCount,
         }), () => abortSession(base, sessionID, directory));
+        reportReply(onReply, reply);
+        const info = reply.info;
         if (info.error) {
             throw new Error(`omms: opencode reported ${info.error.name}: ${formatAssistantError(info.error)}`);
         }
@@ -258,6 +284,7 @@ async function generateViaSdkClient(client, args) {
         if (!data.info) {
             throw new Error("omms: prompt response missing `info`");
         }
+        reportReply(args.onReply, data);
         if (data.info.error) {
             throw new Error(`omms: opencode reported ${data.info.error.name}: ${formatAssistantError(data.info.error)}`);
         }
@@ -387,7 +414,7 @@ async function promptSession(base, args) {
     if (!data.info) {
         throw new Error("omms: prompt response missing `info`");
     }
-    return data.info;
+    return data;
 }
 async function abortSession(base, sessionID, directory) {
     const url = `${base}/session/${encodeURIComponent(sessionID)}/abort${buildQuery(directory)}`;

package/dist/services/ai/providers/anthropic-messages.js

@@ -1,4 +1,4 @@
-import { applySafeExtraParams, BaseAIProvider } from "./base-provider.js";
+import { applySafeExtraParams, BaseAIProvider, describeValidationError, } from "./base-provider.js";
 import { AISessionManager } from "../session/ai-session-manager.js";
 import { ToolSchemaConverter } from "../tools/tool-schema.js";
 import { log } from "../../logger.js";
@@ -48,6 +48,8 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
         return "Anthropic API request timeout";
     }
     async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        // Last stop reason the provider reported, so capture diagnostics can see length limits.
+        let stopReason;
         const providerTag = this.sessionProviderTag();
         let session = await this.aiSessionManager.getSession(sessionId, providerTag);
         if (!session) {
@@ -119,12 +121,14 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
                         iteration: iterations,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: `API error: ${response.status} - ${errorText}`,
                         iterations,
                     };
                 }
                 const data = (await response.json());
+                stopReason = data.stop_reason;
                 const assistantSequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
                 await this.aiSessionManager.addMessage({
                     aiSessionId: session.id,
@@ -145,26 +149,27 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
                             throw new Error(result.errors.join(", "));
                         }
                         return {
+                            stopReason,
                             success: true,
                             data: result.data,
                             iterations,
                         };
                     }
                     catch (validationError) {
-                        const errorStack = validationError instanceof Error ? validationError.stack : undefined;
                         log(this.toolValidationErrorLogLabel(), {
-                            error: String(validationError),
-                            stack: errorStack,
+                            error: describeValidationError(validationError),
                             errorType: validationError instanceof Error
                                 ? validationError.constructor.name
                                 : typeof validationError,
                             toolName: toolSchema.function.name,
                             iteration: iterations,
-                            rawData: JSON.stringify(toolUse).slice(0, 500),
+                            // Log only the size: the tool input is the model's reply.
+                            inputChars: JSON.stringify(toolUse)?.length ?? 0,
                         });
                         return {
+                            stopReason,
                             success: false,
-                            error: `Validation failed: ${String(validationError)}`,
+                            error: `Validation failed: ${describeValidationError(validationError)}`,
                             iterations,
                         };
                     }
@@ -188,12 +193,14 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
                 clearTimeout(timeout);
                 if (error instanceof Error && error.name === "AbortError") {
                     return {
+                        stopReason,
                         success: false,
                         error: `${this.timeoutLabel()} (${this.config.iterationTimeout}ms)`,
                         iterations,
                     };
                 }
                 return {
+                    stopReason,
                     success: false,
                     error: String(error),
                     iterations,
@@ -201,6 +208,7 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
             }
         }
         return {
+            stopReason,
             success: false,
             error: `Max iterations (${maxIterations}) reached without tool use`,
             iterations,

package/dist/services/ai/providers/base-provider.d.ts

@@ -3,6 +3,8 @@ export interface ToolCallResult {
     data?: any;
     error?: string;
     iterations?: number;
+    /** The provider's last reported stop reason, e.g. a length limit. */
+    stopReason?: string;
 }
 export interface ProviderConfig {
     model: string;
@@ -14,6 +16,12 @@ export interface ProviderConfig {
     memoryTemperature?: number | false;
     extraParams?: Record<string, unknown>;
 }
+/**
+ * A validation error message that is safe to log and return. A JSON
+ * `SyntaxError` message quotes the start of the model's reply, which can carry
+ * conversation content, so it is replaced; validator messages name fields only.
+ */
+export declare function describeValidationError(error: unknown): string;
 export declare function applySafeExtraParams(requestBody: Record<string, any>, extraParams: Record<string, unknown>): void;
 export declare abstract class BaseAIProvider {
     protected config: ProviderConfig;

package/dist/services/ai/providers/base-provider.js

@@ -1,3 +1,15 @@
+/**
+ * A validation error message that is safe to log and return. A JSON
+ * `SyntaxError` message quotes the start of the model's reply, which can carry
+ * conversation content, so it is replaced; validator messages name fields only.
+ */
+export function describeValidationError(error) {
+    if (error instanceof SyntaxError)
+        return "tool arguments are not valid JSON";
+    if (error instanceof Error)
+        return error.message;
+    return "unknown validation error";
+}
 const PROTECTED_KEYS = new Set([
     "model",
     "messages",

package/dist/services/ai/providers/google-gemini.js

@@ -1,4 +1,4 @@
-import { BaseAIProvider } from "./base-provider.js";
+import { BaseAIProvider, describeValidationError } from "./base-provider.js";
 import { AISessionManager } from "../session/ai-session-manager.js";
 import { log } from "../../logger.js";
 import { UserProfileValidator } from "../validators/user-profile-validator.js";
@@ -41,6 +41,8 @@ export class GoogleGeminiProvider extends BaseAIProvider {
         });
     }
     async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        // Last stop reason the provider reported, so capture diagnostics can see length limits.
+        let stopReason;
         let session = await this.aiSessionManager.getSession(sessionId, "google-gemini");
         if (!session) {
             session = await this.aiSessionManager.createSession({
@@ -152,6 +154,7 @@ export class GoogleGeminiProvider extends BaseAIProvider {
                         iteration: iterations,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: `Gemini API error: ${response.status} - ${errorText}`,
                         iterations,
@@ -159,8 +162,14 @@ export class GoogleGeminiProvider extends BaseAIProvider {
                 }
                 const data = (await response.json());
                 const candidate = data.candidates?.[0];
+                stopReason = candidate?.finishReason;
                 if (!candidate || !candidate.content) {
-                    return { success: false, error: "Invalid Gemini API response format", iterations };
+                    return {
+                        stopReason,
+                        success: false,
+                        error: "Invalid Gemini API response format",
+                        iterations,
+                    };
                 }
                 const modelMsg = candidate.content;
                 const assistantSequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
@@ -197,12 +206,12 @@ export class GoogleGeminiProvider extends BaseAIProvider {
                                 if (!result.valid)
                                     throw new Error(result.errors.join(", "));
                                 await this.addToolResponse(session.id, contents, toolCall.id, JSON.stringify({ success: true }));
-                                return { success: true, data: result.data, iterations };
+                                return { stopReason, success: true, data: result.data, iterations };
                             }
                             catch (validationError) {
-                                const errorMessage = `Validation failed: ${String(validationError)}`;
+                                const errorMessage = `Validation failed: ${describeValidationError(validationError)}`;
                                 await this.addToolResponse(session.id, contents, toolCall.id, JSON.stringify({ success: false, error: errorMessage }));
-                                return { success: false, error: errorMessage, iterations };
+                                return { stopReason, success: false, error: errorMessage, iterations };
                             }
                         }
                     }
@@ -220,9 +229,14 @@ export class GoogleGeminiProvider extends BaseAIProvider {
             }
             catch (error) {
                 clearTimeout(timeout);
-                return { success: false, error: String(error), iterations };
+                return { stopReason, success: false, error: String(error), iterations };
             }
         }
-        return { success: false, error: `Max iterations (${maxIterations}) reached`, iterations };
+        return {
+            stopReason,
+            success: false,
+            error: `Max iterations (${maxIterations}) reached`,
+            iterations,
+        };
     }
 }

package/dist/services/ai/providers/openai-chat-completion.js

@@ -1,4 +1,4 @@
-import { BaseAIProvider, applySafeExtraParams, } from "./base-provider.js";
+import { BaseAIProvider, applySafeExtraParams, describeValidationError, } from "./base-provider.js";
 import { log } from "../../logger.js";
 import { UserProfileValidator } from "../validators/user-profile-validator.js";
 function isErrorResponseBody(data) {
@@ -126,6 +126,8 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
         return result;
     }
     async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        // Last stop reason the provider reported, so capture diagnostics can see length limits.
+        let stopReason;
         let session = await this.aiSessionManager.getSession(sessionId, this.sessionProviderTag());
         if (!session) {
             session = await this.aiSessionManager.createSession({
@@ -218,6 +220,7 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                             'Your model does not support the temperature parameter. Add "memoryTemperature": false to your config file to disable it.';
                     }
                     return {
+                        stopReason,
                         success: false,
                         error: errorMessage,
                         iterations,
@@ -232,6 +235,7 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                         msg: data.msg,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: `API error: ${data.status} - ${data.msg}`,
                         iterations,
@@ -244,19 +248,24 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                     log("Invalid API response format", {
                         provider: this.getProviderName(),
                         model: this.config.model,
-                        response: JSON.stringify(data).slice(0, 1000),
+                        // The body can carry reply text, so log only its shape and size.
+                        responseKeys: typeof data === "object" && data !== null ? Object.keys(data).slice(0, 20) : [],
+                        responseChars: JSON.stringify(data)?.length ?? 0,
                         hasChoices: Array.isArray(choices),
                         choicesLength: Array.isArray(choices) ? choices.length : undefined,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: "Invalid API response format",
                         iterations,
                     };
                 }
                 const choice = data.choices[0];
+                stopReason = choice?.finish_reason ?? undefined;
                 if (!choice) {
                     return {
+                        stopReason,
                         success: false,
                         error: "Invalid API response format",
                         iterations,
@@ -318,27 +327,28 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                                 }
                                 await this.addToolResponse(session.id, messages, toolCallId, JSON.stringify({ success: true }));
                                 return {
+                                    stopReason,
                                     success: true,
                                     data: result.data,
                                     iterations,
                                 };
                             }
                             catch (validationError) {
-                                const errorStack = validationError instanceof Error ? validationError.stack : undefined;
                                 log("OpenAI tool response validation failed", {
-                                    error: String(validationError),
-                                    stack: errorStack,
+                                    error: describeValidationError(validationError),
                                     errorType: validationError instanceof Error
                                         ? validationError.constructor.name
                                         : typeof validationError,
                                     toolName: toolSchema.function.name,
                                     iteration: iterations,
-                                    rawArguments: toolCall.function.arguments.slice(0, 500),
+                                    // Log only the size: the arguments are the model's reply.
+                                    argumentsChars: toolCall.function.arguments.length,
                                 });
-                                const errorMessage = `Validation failed: ${String(validationError)}`;
+                                const errorMessage = `Validation failed: ${describeValidationError(validationError)}`;
                                 lastErrorMessage = errorMessage;
                                 await this.addToolResponse(session.id, messages, toolCallId, JSON.stringify({ success: false, error: errorMessage }));
                                 return {
+                                    stopReason,
                                     success: false,
                                     error: errorMessage,
                                     iterations,
@@ -366,12 +376,14 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                 clearTimeout(timeout);
                 if (error instanceof Error && error.name === "AbortError") {
                     return {
+                        stopReason,
                         success: false,
                         error: `API request timeout (${iterationTimeout}ms)`,
                         iterations,
                     };
                 }
                 return {
+                    stopReason,
                     success: false,
                     error: String(error),
                     iterations,
@@ -379,6 +391,7 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
             }
         }
         return {
+            stopReason,
             success: false,
             error: `Max iterations (${maxIterations}) reached without tool call`,
             iterations,

package/dist/services/ai/providers/openai-responses.js

@@ -15,6 +15,8 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
         return true;
     }
     async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        // Last stop reason the provider reported, so capture diagnostics can see length limits.
+        let stopReason;
         let session = await this.aiSessionManager.getSession(sessionId, "openai-responses");
         if (!session) {
             session = await this.aiSessionManager.createSession({
@@ -67,12 +69,17 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                         iteration: iterations,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: `API error: ${response.status} - ${errorText}`,
                         iterations,
                     };
                 }
                 const data = (await response.json());
+                stopReason =
+                    data.status === "incomplete"
+                        ? (data.incomplete_details?.reason ?? "incomplete")
+                        : data.status;
                 conversationId = data.conversation || conversationId;
                 if (iterations === 1) {
                     const userSeq = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
@@ -89,6 +96,7 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                         conversationId,
                     });
                     return {
+                        stopReason,
                         success: true,
                         data: this.validateResponse(toolCall),
                         iterations,
@@ -100,12 +108,14 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                 clearTimeout(timeout);
                 if (error instanceof Error && error.name === "AbortError") {
                     return {
+                        stopReason,
                         success: false,
                         error: `API request timeout (${this.config.iterationTimeout}ms)`,
                         iterations,
                     };
                 }
                 return {
+                    stopReason,
                     success: false,
                     error: String(error),
                     iterations,
@@ -113,6 +123,7 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
             }
         }
         return {
+            stopReason,
             success: false,
             error: `Max iterations (${this.config.maxIterations}) reached without tool call`,
             iterations,

package/dist/services/capture-diagnostics.d.ts

@@ -0,0 +1,66 @@
+import type { CaptureAttemptDiagnostics, CaptureAttemptOutcome, CaptureExtractionPath, CaptureFailureReason } from "../core/host.js";
+import type { MemoryHost, MemorySourceType } from "../types/index.js";
+/**
+ * The config fields this module reads. Callers pass `CONFIG`; tests pass a
+ * plain object, so no import of `../config.js` is needed here.
+ */
+export interface CaptureDiagnosticsConfig {
+    captureTrace?: boolean;
+    captureTraceRetentionDays?: number;
+    memoryApiKey?: string;
+    embeddingApiKey?: string;
+    webServerApiToken?: string;
+    webServerAuthPassword?: string;
+}
+export interface CaptureAttemptContext {
+    host: MemoryHost;
+    sourceType: MemorySourceType;
+    sessionId: string;
+}
+/**
+ * The metadata-only record written to the OMMS log for every attempt. Every
+ * key is always present so records from both hosts have one shape; a value a
+ * path could not observe is null.
+ */
+export interface CaptureAttemptRecord {
+    host: MemoryHost;
+    sourceType: MemorySourceType;
+    sessionId: string;
+    path: CaptureExtractionPath | null;
+    provider: string | null;
+    model: string | null;
+    stopReason: string | null;
+    blockTypes: string[] | null;
+    promptChars: number | null;
+    replyChars: number | null;
+    durationMs: number;
+    outcome: CaptureAttemptOutcome;
+    reason: CaptureFailureReason | null;
+}
+export declare const DEFAULT_CAPTURE_TRACE_RETENTION_DAYS = 7;
+export declare function buildCaptureAttemptRecord(context: CaptureAttemptContext, diagnostics: CaptureAttemptDiagnostics, outcome: CaptureAttemptOutcome, durationMs: number): CaptureAttemptRecord;
+/**
+ * Prepare prompt or reply text for the trace file: drop `<private>` regions the
+ * same way memory storage does, then configured secrets, then common key and
+ * token formats.
+ */
+export declare function redactTraceText(text: string, config: CaptureDiagnosticsConfig): string;
+export declare function getTraceDirectory(): string;
+/**
+ * Delete trace files dated more than `captureTraceRetentionDays` before `now`.
+ * The date comes from the file name, not the modification time, and files
+ * that do not match the trace name pattern are never touched.
+ */
+export declare function pruneTraces(config: CaptureDiagnosticsConfig, now?: Date): number;
+/**
+ * Append one trace entry to the day's JSON Lines file. A single append per
+ * entry keeps lines whole when Pi and OpenCode write at the same time.
+ */
+export declare function writeTraceEntry(record: CaptureAttemptRecord, diagnostics: CaptureAttemptDiagnostics, config: CaptureDiagnosticsConfig, now?: Date): void;
+/**
+ * Write the attempt's metadata record to the log and, when tracing is on, its
+ * trace entry. Never throws: diagnostics must not change a capture outcome.
+ */
+export declare function emitCaptureAttempt(record: CaptureAttemptRecord, diagnostics: CaptureAttemptDiagnostics, config: CaptureDiagnosticsConfig, now?: Date): void;
+/** Test hook: forget which day the last trace was written. */
+export declare function resetTraceStateForTests(): void;