@stackfactor/agent-utils 1.0.11 → 1.0.13

package/dist/cjs/langChain.js

@@ -12,34 +12,7 @@ const const_js_1 = __importDefault(require("./const.js"));
 const langchain_1 = __importDefault(require("langchain"));
 const errorHandling_js_1 = __importDefault(require("./errorHandling.js"));
 const logger_js_1 = __importDefault(require("./logger.js"));
-const zod_1 = require("zod");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
-const NDJSON_SYSTEM_PROMPT = `
-You are a streaming JSON generator.
-
-You MUST output NDJSON (newline-delimited JSON).
-That means: ONE valid JSON object per line.
-
-Allowed event types:
-- "progress": short status update for the user
-- "final": final complete result
-
-Rules:
-- Output ONLY NDJSON lines (no markdown, no extra text).
-- Each line must be valid JSON.
-- "progress" must include: type, message, pct (with values between {minPercent} and {maxPercent})
-- "final" must include: type, content
-- End with EXACTLY ONE "final" event.
-- Do NOT reveal hidden chain-of-thought.
-
-CRITICAL - Escape special characters in ALL string values:
-- Newlines must be written as \\n (two characters: backslash + n)
-- Tabs must be written as \\t (two characters: backslash + t)
-- Carriage returns must be written as \\r (two characters: backslash + r)
-- Double quotes inside strings must be written as \\"
-- Backslashes must be written as \\\\
-This ensures valid JSON output.
-`.trim();
 const JSON_ESCAPE_INSTRUCTION = `
 CRITICAL - Your response must be valid JSON. Escape ALL special characters in string values:
 - Newlines → \\n
@@ -49,45 +22,41 @@ CRITICAL - Your response must be valid JSON. Escape ALL special characters in st
 - Backslashes → \\\\
 Do NOT include raw newlines, tabs, or unescaped quotes inside JSON string values.
 `.trim();
-const REPORT_PROGRESS_TOOL = `
-Report Progress to User
-Before each task or step, call the tool report_progress with:
-  message: brief description of work you plan to do that makes sense for individuals in Learning and Development or Business Strategy roles. Don't include the word JSON in any of the messages.
-  percent: cumulative completion percentage with values between {minPercent}% and {maxPercent}%. Don't report percentage completion outside of this range.
-`;
 /**
  * Converts a Zod validation error object into a human-readable multi-line string.
  * Each failing field is described with its dot-notation path and a contextual message
  * that depends on the Zod error code (e.g. `invalid_type`, `too_small`, `invalid_enum_value`).
  * The output is prefixed with `"Schema validation failed:"` followed by a bulleted list.
- * @param zodError - The Zod `ZodError` instance whose `errors` array will be formatted
+ * @param zodError - The Zod `ZodError` instance whose `issues` array will be formatted
  * @returns A formatted string describing all validation failures
  */
 const formatZodErrors = (zodError) => {
-    const errors = zodError.errors.map((err) => {
-        const path = err.path.length > 0 ? err.path.join(".") : "root";
-        // Provide more context based on error type
-        switch (err.code) {
-            case "invalid_type":
-                return `Field "${path}": Expected ${err.expected}, but received ${err.received}`;
-            case "invalid_literal":
-                return `Field "${path}": Expected literal value ${JSON.stringify(err.expected)}, but received ${JSON.stringify(err.received)}`;
-            case "unrecognized_keys":
-                return `Field "${path}": Unrecognized keys: ${err.keys.join(", ")}`;
-            case "invalid_union":
-                return `Field "${path}": Invalid union - none of the expected types matched`;
-            case "invalid_enum_value":
-                return `Field "${path}": Invalid enum value. Expected one of: ${err.options.join(", ")}`;
-            case "invalid_string":
-                return `Field "${path}": Invalid string format (${err.validation})`;
-            case "too_small":
-                return `Field "${path}": Value is too small (minimum: ${err.minimum})`;
-            case "too_big":
-                return `Field "${path}": Value is too large (maximum: ${err.maximum})`;
-            default:
-                return `Field "${path}": ${err.message}`;
-        }
-    });
+    const errors = zodError.issues
+        ? zodError.issues.map((err) => {
+            const path = err.path.length > 0 ? err.path.join(".") : "root";
+            // Provide more context based on error type
+            switch (err.code) {
+                case "invalid_type":
+                    return `Field "${path}": Expected ${err.expected}, but received ${err.received}`;
+                case "invalid_literal":
+                    return `Field "${path}": Expected literal value ${JSON.stringify(err.expected)}, but received ${JSON.stringify(err.received)}`;
+                case "unrecognized_keys":
+                    return `Field "${path}": Unrecognized keys: ${err.keys.join(", ")}`;
+                case "invalid_union":
+                    return `Field "${path}": Invalid union - none of the expected types matched`;
+                case "invalid_enum_value":
+                    return `Field "${path}": Invalid enum value. Expected one of: ${err.options.join(", ")}`;
+                case "invalid_string":
+                    return `Field "${path}": Invalid string format (${err.validation})`;
+                case "too_small":
+                    return `Field "${path}": Value is too small (minimum: ${err.minimum})`;
+                case "too_big":
+                    return `Field "${path}": Value is too large (maximum: ${err.maximum})`;
+                default:
+                    return `Field "${path}": ${err.message}`;
+            }
+        })
+        : [];
     return `Schema validation failed:\n  - ${errors.join("\n  - ")}`;
 };
 /**
@@ -222,82 +191,6 @@ const extractJSONFromResponse = (text) => {
     }
     return null;
 };
-/**
- * Attempts to parse a JSON string without throwing. On failure it tries a second parse
- * after sanitising Unicode control characters and normalising Windows-style line endings
- * to `\n`. Returns `null` if both attempts fail, making it safe to call in stream
- * processing loops where individual NDJSON lines may be malformed.
- * @param line - A single line of text expected to contain a JSON value
- * @returns The parsed value, or `null` if parsing failed after both attempts
- */
-const safeJsonParse = (line) => {
-    try {
-        return JSON.parse(line);
-    }
-    catch {
-        // Try with special character handling
-        try {
-            const sanitized = line
-                .replace(/[\u0000-\u001F\u007F-\u009F]/g, " ")
-                .replace(/\r\n/g, "\\n")
-                .replace(/\r/g, "\\n");
-            return JSON.parse(sanitized);
-        }
-        catch {
-            return null;
-        }
-    }
-};
-/**
- * Creates a LangChain tool named `report_progress` that agents can call to emit
- * progress updates during multi-step execution. When the tool is invoked by the agent,
- * it clamps the reported percentage to the `[minPercent, maxPercent]` range, forwards
- * the update to the `onProgress` callback, and returns a JSON acknowledgement string to
- * the agent. If the callback throws, the tool returns a JSON error acknowledgement
- * instead of propagating the exception.
- * @param onProgress - Async or sync callback invoked with `{ progress, message }` on
- *   each agent progress report
- * @param minPercent - The lower bound of the percentage range the agent is allowed to
- *   report; defaults to `0`
- * @param maxPercent - The upper bound of the percentage range the agent is allowed to
- *   report; defaults to `100`
- * @returns A LangChain tool instance configured with a Zod schema for `{ stage, message, percent }`
- */
-const getAIProgressTool = (onProgress, minPercent = 0, maxPercent = 100) => langchain_1.default.tool(async ({ stage, message, percent }) => {
-    let clampedPct = 0;
-    try {
-        // Coerce percent to number and clamp to be within minPercent and maxPercent bounds
-        const rawPct = typeof percent === "number" ? percent : parseFloat(percent) || 0;
-        clampedPct = Math.max(minPercent, Math.min(maxPercent, rawPct));
-        // NOTE: Monotonicity is not enforced here; implement if needed per session/context.
-        if (onProgress &&
-            minPercent <= clampedPct &&
-            clampedPct <= maxPercent) {
-            await onProgress({
-                progress: clampedPct,
-                message: message,
-            });
-        }
-    }
-    finally {
-        return JSON.stringify({
-            acknowledged: true,
-            receivedAt: Date.now(),
-            stage,
-            percent: clampedPct,
-        });
-    }
-}, {
-    name: "report_progress",
-    description: `Mandatory after each phase: call with {stage, message, percent}. Percent must be between ${minPercent} and ${maxPercent} and monotonically increase.`,
-    schema: zod_1.z.object({
-        stage: zod_1.z.string().describe("Current stage of the process"),
-        message: zod_1.z.string().describe("Progress message to display"),
-        percent: zod_1.z
-            .number()
-            .describe(`Progress percentage (${minPercent}-${maxPercent})`),
-    }),
-});
 /**
  * Instantiates and returns the appropriate LangChain chat model based on the model
  * name prefix. `claude-` maps to `ChatAnthropic`, `gemini-` maps to
@@ -363,11 +256,7 @@ const getLLMModel = (modelName, config, schema = null) => {
 };
 /**
  * Constructs a LangChain agent configured with a specified model, system prompt, and
- * set of tools. When an `onReportProgress` callback is provided, the NDJSON progress-
- * reporting instruction block is appended to the system prompt and a `report_progress`
- * tool is added to the tools array so the agent can emit incremental progress updates
- * during execution. The percentage range for progress reporting is bounded by
- * `minPercent` and `maxPercent`.
+ * set of tools.
  * @param name - A human-readable display name for the agent
  * @param modelName - The LLM identifier passed to `getLLMModel` (e.g. `"gpt-4o"`)
  * @param systemPrompt - The base system prompt describing the agent's role and behaviour
@@ -376,30 +265,14 @@ const getLLMModel = (modelName, config, schema = null) => {
  * @param responseFormat - Optional structured response format descriptor passed to the
  *   LangChain agent constructor
  * @param config - Configuration object forwarded to `getLLMModel` (API keys, temperature, etc.)
- * @param onReportProgress - Optional callback for progress updates; when provided the
- *   progress tool is added and the system prompt is extended
- * @param minPercent - Minimum progress percentage the agent is allowed to report;
- *   defaults to `0`
- * @param maxPercent - Maximum progress percentage the agent is allowed to report;
- *   defaults to `100`
- * @returns A configured LangChain agent instance ready to be run with `runAIAgent`
+ * @returns A configured LangChain agent instance ready to be run with `runAgent`
  */
-const createAgent = (name, modelName, systemPrompt, tools = [], responseFormat, config, onReportProgress = null, minPercent = 0, maxPercent = 100) => {
-    //Prepare the complete system prompt with progress reporting instructions if needed
-    const completeSystemPrompt = `
-        ${systemPrompt}
-        ${onReportProgress
-        ? REPORT_PROGRESS_TOOL.replace(`{minPercent}`, minPercent).replace(`{maxPercent}`, maxPercent)
-        : ""}
-      `.trim();
-    // Create the agent with the specified model, system prompt, tools, and response format
+const createAgent = (name, modelName, systemPrompt, tools = [], responseFormat, config) => {
     const agent = langchain_1.default.createAgent({
         name: name,
         model: getLLMModel(modelName, config),
-        systemPrompt: completeSystemPrompt,
-        tools: onReportProgress
-            ? [...tools, getAIProgressTool(onReportProgress, minPercent, maxPercent)]
-            : tools,
+        systemPrompt: systemPrompt.trim(),
+        tools,
         ...(responseFormat ? { responseFormat: responseFormat } : {}),
     });
     return agent;
@@ -407,10 +280,9 @@ const createAgent = (name, modelName, systemPrompt, tools = [], responseFormat,
 /**
  * Executes a LangChain agent with a single user prompt and returns the raw agent
  * response. When an `onProgress` callback is provided, LangChain callbacks are
- * registered to forward `tool_start`, `tool_end` (including structured progress data
- * from the `report_progress` tool), `agent_action`, and error events to the caller.
+ * registered to forward `tool_start`, `agent_action`, and error events to the caller.
  * Execution time is logged at the info level on completion.
- * @param agent - A LangChain agent instance created by `createAIAgent`
+ * @param agent - A LangChain agent instance created by `createAgent`
  * @param prompt - The user message string to send to the agent
  * @param config - Configuration object; `config.recursionLimit` controls the maximum
  *   number of agent steps (defaults to `25` when not specified)
@@ -420,8 +292,6 @@ const createAgent = (name, modelName, systemPrompt, tools = [], responseFormat,
  */
 const runAgent = async (agent, prompt, config, onProgress = null) => {
     const startTime = Date.now();
-    // Build callbacks for progress reporting if onProgress is provided
-    // const agentDisplayName = `${agent.options?.name} AI Agent`;
     const callbacks = onProgress
         ? [
             {
@@ -433,24 +303,6 @@ const runAgent = async (agent, prompt, config, onProgress = null) => {
                             tool: toolInfo.name,
                         });
                 },
-                handleToolEnd: (output) => {
-                    try {
-                        const progressInfo = extractJSONFromResponse(output.content);
-                        if (progressInfo &&
-                            typeof progressInfo === "object" &&
-                            progressInfo.percent &&
-                            progressInfo.message) {
-                            onProgress({
-                                progress: progressInfo.percent,
-                                message: progressInfo.message,
-                                output: typeof output === "string"
-                                    ? output
-                                    : JSON.stringify(output),
-                            });
-                        }
-                    }
-                    catch { }
-                },
                 handleAgentAction: (action) => {
                     onProgress({
                         type: "agent_action",
@@ -459,18 +311,6 @@ const runAgent = async (agent, prompt, config, onProgress = null) => {
                         input: action.toolInput,
                     });
                 },
-                // handleLLMStart: () => {
-                //   onProgress({
-                //     type: "llm_start",
-                //     message: `${agentDisplayName} is thinking`,
-                //   });
-                // },
-                // handleLLMEnd: () => {
-                //   onProgress({
-                //     type: "llm_end",
-                //     message: `${agentDisplayName} has completed processing`,
-                //   });
-                // },
                 handleChainError: (err) => {
                     onProgress({
                         type: "error",
@@ -574,26 +414,11 @@ const runPromptWithModel = async (modelName, config, prompt, onProgressReport, m
                 ? `${JSON_ESCAPE_INSTRUCTION}\n\n---\n\n${systemPrompt}`
                 : JSON_ESCAPE_INSTRUCTION;
         }
-        // Build tools array and progress callback for agentic mode
-        const progressTracker = { current: minPercent };
-        const agentTools = [...tools];
-        let trackingProgressCallback = null;
-        if (onProgressReport) {
-            trackingProgressCallback = (data) => {
-                if (typeof data.progress === "number") {
-                    progressTracker.current = data.progress;
-                }
-                onProgressReport(data);
-            };
-        }
-        // Create the agent with tools and progress callback
-        const agent = createAgent(agentName, modelName, systemPrompt, agentTools, null, // responseFormat
-        config, trackingProgressCallback, minPercent, maxPercent);
-        // Run the agent with callback that includes current progress
-        const callbackWithProgress = onProgressReport
-            ? (data) => onProgressReport({ ...data, progress: progressTracker.current })
-            : null;
-        const response = await runAgent(agent, userPrompt, config, callbackWithProgress);
+        // Create the agent with tools
+        const agent = createAgent(agentName, modelName, systemPrompt, [...tools], null, // responseFormat
+        config);
+        // Run the agent with progress callback
+        const response = await runAgent(agent, userPrompt, config, onProgressReport || null);
         // Extract content from agent response
         const messages = response?.messages || [];
         if (messages.length === 0) {
@@ -666,224 +491,112 @@ const runPromptWithModel = async (modelName, config, prompt, onProgressReport, m
         throw new Error("Prompt must be a string or array of messages");
     }
     if (onProgressReport) {
-        // Check if we can use native response_format (OpenAI with schema)
-        const useNativeStreamingSchema = expectsJsonResponse && schema && modelName.startsWith("gpt-");
-        if (useNativeStreamingSchema) {
-            // OpenAI with schema: use native response_format and stream with chunk-based progress
-            const llm = getLLMModel(modelName, config, schema);
-            const messagesToSend = messages.length > 0 && messages[0].role === "system"
-                ? messages
-                : [
-                    { role: "system", content: "Respond with valid JSON." },
-                    ...messages,
+        // Streaming mode: use server-side chunk-based progress for all models
+        const useNativeSchema = expectsJsonResponse && schema && modelName.startsWith("gpt-");
+        const llm = getLLMModel(modelName, config, useNativeSchema ? schema : null);
+        // Build messages with JSON instructions if needed
+        let messagesToSend;
+        if (expectsJsonResponse) {
+            let systemContent = useNativeSchema
+                ? "Respond with valid JSON."
+                : JSON_ESCAPE_INSTRUCTION;
+            if (schema && !useNativeSchema) {
+                const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema, { target: "openApi3" });
+                systemContent += `\n\nYour response MUST conform to this JSON schema:\n${JSON.stringify(jsonSchema, null, 2)}`;
+            }
+            if (messages.length > 0 && messages[0].role === "system") {
+                messagesToSend = [
+                    {
+                        role: "system",
+                        content: `${systemContent}\n\n---\n\n${messages[0].content}`,
+                    },
+                    ...messages.slice(1),
                 ];
-            let rawContent = "";
-            let lastProgressReport = 0;
-            const progressInterval = 1000; // Report progress every 1000 characters
-            const stream = await llm.stream(messagesToSend);
-            for await (const chunk of stream) {
-                const content = chunk?.content || chunk;
-                if (typeof content === "string") {
-                    rawContent += content;
-                    // Report progress based on content length
-                    if (rawContent.length - lastProgressReport >= progressInterval) {
-                        lastProgressReport = rawContent.length;
-                        const progress = Math.min(maxPercent - 5, // Reserve last 5% for completion
-                        minPercent +
-                            Math.floor((rawContent.length / 5000) * (maxPercent - minPercent)));
-                        await onProgressReport({
-                            message: "Generating content...",
-                            progress: progress,
-                        });
-                    }
-                }
             }
-            // Report completion
-            await onProgressReport({
-                message: "Processing complete",
-                progress: maxPercent,
-            });
-            // Parse and validate the response
-            if (rawContent) {
-                try {
-                    const parsed = JSON.parse(rawContent.trim());
-                    if (schema) {
-                        validateWithSchema(parsed, schema);
-                    }
-                    return JSON.stringify(parsed);
-                }
-                catch (parseError) {
-                    if (parseError?.code === const_js_1.default.HTTP_CODES.UNPROCESSABLE_ENTITY) {
-                        throw parseError;
-                    }
-                    // Try to extract JSON
-                    const extracted = extractJSONFromResponse(rawContent);
-                    if (extracted) {
-                        if (schema) {
-                            validateWithSchema(extracted, schema);
-                        }
-                        return JSON.stringify(extracted);
-                    }
-                    if (expectsJsonResponse) {
-                        let preview = "";
-                        if (typeof rawContent === "string") {
-                            preview = rawContent.substring(0, 100);
-                        }
-                        else if (typeof rawContent === "object" && rawContent !== null) {
-                            preview = JSON.stringify(rawContent).substring(0, 100);
-                        }
-                        else if (rawContent !== undefined && rawContent !== null) {
-                            preview = String(rawContent).substring(0, 100);
-                        }
-                        else {
-                            preview = "[empty response]";
-                        }
-                        throw errorHandling_js_1.default.create(const_js_1.default.HTTP_CODES.INTERNAL_SERVER_ERROR, `LLM returned non-JSON response when JSON was expected: ${preview}...`);
-                    }
-                    return rawContent;
-                }
+            else {
+                messagesToSend = [
+                    { role: "system", content: systemContent },
+                    ...messages,
+                ];
             }
-            throw errorHandling_js_1.default.create(const_js_1.default.HTTP_CODES.INTERNAL_SERVER_ERROR, "LLM returned no content");
-        }
-        // Non-OpenAI or no schema: use NDJSON streaming approach
-        const llm = getLLMModel(modelName, config);
-        let ndjsonSystemContent = NDJSON_SYSTEM_PROMPT.replace(`{minPercent}`, minPercent).replace(`{maxPercent}`, maxPercent);
-        // If schema is provided, include it in the system prompt
-        if (expectsJsonResponse && schema) {
-            const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema, { target: "openApi3" });
-            ndjsonSystemContent += `\n\nThe "content" field in the "final" event MUST conform to this JSON schema:\n${JSON.stringify(jsonSchema, null, 2)}`;
-        }
-        let messagesWithNDJSON;
-        if (messages.length > 0 && messages[0].role === "system") {
-            messagesWithNDJSON = [
-                {
-                    role: "system",
-                    content: `${ndjsonSystemContent}\n\n---\n\n${messages[0].content}`,
-                },
-                ...messages.slice(1),
-            ];
         }
         else {
-            messagesWithNDJSON = [
-                {
-                    role: "system",
-                    content: ndjsonSystemContent,
-                },
-                ...messages,
-            ];
+            messagesToSend = messages;
         }
-        // Stream the response and parse NDJSON events
-        let buffer = "";
-        let finalContent = "";
+        // Stream and report server-side progress based on time elapsed
         let rawContent = "";
-        const stream = await llm.stream(messagesWithNDJSON);
+        let chunkCount = 0;
+        const progressReportInterval = 10; // Report every N chunks
+        const startTime = Date.now();
+        // Use a time-based asymptotic curve: progress approaches maxPercent but never
+        // overshoots. This avoids the magic "expected length" constant — longer responses
+        // simply slow the curve down rather than exceeding the range.
+        const expectedDurationMs = 15_000; // Tune: expected typical response time
+        const stream = await llm.stream(messagesToSend);
         for await (const chunk of stream) {
             const content = chunk?.content || chunk;
             if (typeof content === "string") {
-                buffer += content;
                 rawContent += content;
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || "";
-                for (const line of lines) {
-                    const trimmedLine = line.trim();
-                    if (!trimmedLine)
-                        continue;
-                    const parsed = safeJsonParse(trimmedLine);
-                    if (parsed) {
-                        if (parsed.type === "progress") {
-                            const clampedProgress = Math.max(minPercent, Math.min(maxPercent, parsed.pct));
-                            await onProgressReport({
-                                message: parsed.message,
-                                progress: clampedProgress,
-                            });
-                        }
-                        else if (parsed.type === "final") {
-                            if (parsed.content) {
-                                finalContent = parsed.content;
-                            }
-                        }
-                    }
+                chunkCount++;
+                if (chunkCount % progressReportInterval === 0) {
+                    const elapsed = Date.now() - startTime;
+                    // Asymptotic curve: fast early progress that slows as it approaches max
+                    const progress = Math.round(minPercent +
+                        (maxPercent - minPercent - 5) *
+                            (1 - Math.exp(-elapsed / expectedDurationMs)));
+                    await onProgressReport({
+                        message: "Generating content...",
+                        progress: Math.min(progress, maxPercent - 5),
+                    });
                 }
             }
         }
-        if (buffer.trim()) {
-            const parsed = safeJsonParse(buffer.trim());
-            if (parsed && parsed.type === "final" && parsed.content) {
-                finalContent = parsed.content;
-            }
+        await onProgressReport({
+            message: "Processing complete",
+            progress: maxPercent,
+        });
+        if (!rawContent) {
+            throw errorHandling_js_1.default.create(const_js_1.default.HTTP_CODES.INTERNAL_SERVER_ERROR, "LLM returned no content");
         }
-        if (finalContent) {
-            if (typeof finalContent === "object") {
-                if (expectsJsonResponse && schema) {
-                    validateWithSchema(finalContent, schema);
-                }
-                return JSON.stringify(finalContent);
-            }
-            if (typeof finalContent === "string") {
-                try {
-                    const parsed = JSON.parse(finalContent);
-                    if (expectsJsonResponse && schema) {
-                        validateWithSchema(parsed, schema);
-                    }
-                    return JSON.stringify(parsed);
-                }
-                catch (parseError) {
-                    if (parseError?.code === const_js_1.default.HTTP_CODES.UNPROCESSABLE_ENTITY) {
-                        throw parseError;
-                    }
-                    return finalContent;
-                }
-            }
-            return finalContent;
+        // If not expecting JSON, return raw content directly
+        if (!expectsJsonResponse) {
+            return rawContent;
         }
-        if (rawContent) {
-            const lines = rawContent.split("\n").filter((l) => l.trim());
-            let extractedContent = "";
-            for (const line of lines) {
-                const parsed = safeJsonParse(line.trim());
-                if (parsed && parsed.type === "final" && parsed.content) {
-                    extractedContent = parsed.content;
-                    break;
-                }
-            }
-            if (extractedContent) {
-                try {
-                    const parsed = JSON.parse(extractedContent);
-                    if (expectsJsonResponse && schema) {
-                        validateWithSchema(parsed, schema);
-                    }
-                    return JSON.stringify(parsed);
-                }
-                catch {
-                    return extractedContent;
+        // Parse and validate JSON response
+        const trimmed = rawContent.trim();
+        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+            (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (schema) {
+                    validateWithSchema(parsed, schema);
                 }
+                return JSON.stringify(parsed);
             }
-            const extracted = extractJSONFromResponse(rawContent);
-            if (extracted) {
-                if (expectsJsonResponse && schema) {
-                    validateWithSchema(extracted, schema);
+            catch (parseError) {
+                if (parseError?.code === const_js_1.default.HTTP_CODES.UNPROCESSABLE_ENTITY) {
+                    throw parseError;
                 }
-                return JSON.stringify(extracted);
             }
-            if (expectsJsonResponse) {
-                let preview = "";
-                if (typeof rawContent === "string") {
-                    preview = rawContent.substring(0, 100);
-                }
-                else if (typeof rawContent === "object" && rawContent !== null) {
-                    preview = JSON.stringify(rawContent).substring(0, 100);
-                }
-                else if (rawContent !== undefined && rawContent !== null) {
-                    preview = String(rawContent).substring(0, 100);
-                }
-                else {
-                    preview = "[empty response]";
-                }
-                throw errorHandling_js_1.default.create(const_js_1.default.HTTP_CODES.INTERNAL_SERVER_ERROR, `LLM returned non-JSON response when JSON was expected: ${preview}...`);
+        }
+        const extracted = extractJSONFromResponse(rawContent);
+        if (extracted) {
+            if (schema) {
+                validateWithSchema(extracted, schema);
             }
-            return rawContent;
+            return JSON.stringify(extracted);
+        }
+        let preview = "";
+        if (typeof rawContent === "string") {
+            preview = rawContent.substring(0, 100);
+        }
+        else if (typeof rawContent === "object" && rawContent !== null) {
+            preview = JSON.stringify(rawContent).substring(0, 100);
+        }
+        else {
+            preview = "[empty response]";
         }
-        throw errorHandling_js_1.default.create(const_js_1.default.HTTP_CODES.INTERNAL_SERVER_ERROR, "LLM returned no content");
+        throw errorHandling_js_1.default.create(const_js_1.default.HTTP_CODES.INTERNAL_SERVER_ERROR, `LLM returned non-JSON response when JSON was expected: ${preview}...`);
     }
     else {
         // Non-streaming mode: use native response_format for OpenAI when schema is provided

package/dist/esm/langChain.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    createAgent: (name: string, modelName: string, systemPrompt: string, tools: any[], responseFormat: any, config: any, onReportProgress?: Function | null, minPercent?: number, maxPercent?: number) => any;
+    createAgent: (name: string, modelName: string, systemPrompt: string, tools: any[], responseFormat: any, config: any) => any;
     runAgent: (agent: any, prompt: string, config: any, onProgress?: Function | null) => Promise<any>;
     runChatPromptWithModel: (modelName: string, config: any, prompt: any, onProgressReport: any) => any;
     runPromptWithModel: (modelName: string, config: any, prompt: any, onProgressReport: any, minPercent?: number, maxPercent?: number, expectsJsonResponse?: boolean, schema?: any, agentName?: string, tools?: any[]) => Promise<any>;