mdi-llmkit 1.0.1 → 1.0.6

package/dist/src/jsonSurgery/jsonSurgery.js

@@ -175,170 +175,170 @@ export const jsonSurgery = async (openaiClient, obj, modificationInstructions, o
     obj = JSON.parse(JSON.stringify(obj));
     const timeStarted = Date.now();
     const convoBase = new GptConversation([], { openaiClient });
-    convoBase.addDeveloperMessage(`
-You are an expert software developer AI assistant.
-The user will show you a JSON object and provide modification instructions.
-The modification instructions might not be entirely straightforward, so the
-process of implementing these changes may require careful thought and planning.
-Through a series of individual insertions, deletions, or updates, you will modify the JSON object
-to satisfy the user's instructions.
-You will not be doing this alone. I will be holding your hand through the entire process,
-providing feedback and guidance after each modification. You will also be getting verification
-from the system itself, to ensure that your modifications are valid and correct.
+    convoBase.addDeveloperMessage(`
+You are an expert software developer AI assistant.
+The user will show you a JSON object and provide modification instructions.
+The modification instructions might not be entirely straightforward, so the
+process of implementing these changes may require careful thought and planning.
+Through a series of individual insertions, deletions, or updates, you will modify the JSON object
+to satisfy the user's instructions.
+You will not be doing this alone. I will be holding your hand through the entire process,
+providing feedback and guidance after each modification. You will also be getting verification
+from the system itself, to ensure that your modifications are valid and correct.
 `);
-    convoBase.addUserMessage(`
-
-Here is the JSON object to modify, in its original state prior to any modifications.
-It has been formatted with placemarks (comments) to indicate the positions of elements for
-better readability and easier navigation.
-
----
-
-${placemarkedJSONStringify(obj, 2, options.skippedKeys)}
+    convoBase.addUserMessage(`
+
+Here is the JSON object to modify, in its original state prior to any modifications.
+It has been formatted with placemarks (comments) to indicate the positions of elements for
+better readability and easier navigation.
+
+---
+
+${placemarkedJSONStringify(obj, 2, options.skippedKeys)}
 `);
     if (options.schemaDescription) {
-        convoBase.addUserMessage(`
-Here is the schema definition for the JSON object, so that you know the expected structure
-and data types of its properties. Make sure that your final results conform to this schema.
-DO NOT introduce any properties or values that violate this schema!
-
----
-
-${options.schemaDescription}
+        convoBase.addUserMessage(`
+Here is the schema definition for the JSON object, so that you know the expected structure
+and data types of its properties. Make sure that your final results conform to this schema.
+DO NOT introduce any properties or values that violate this schema!
+
+---
+
+${options.schemaDescription}
 `);
     }
-    convoBase.addUserMessage(`
-
-Here are the modification instructions.
-
----
-
-${modificationInstructions}
+    convoBase.addUserMessage(`
+
+Here are the modification instructions.
+
+---
+
+${modificationInstructions}
 `);
-    convoBase.addDeveloperMessage(`
-Before we begin, please provide a detailed plan outlining the specific steps you will take to
-implement the requested modifications to the JSON object. This plan should break down the
-modification instructions into a clear sequence of actions that you will perform, where each
-action corresponds to a specific change in the JSON structure -- either the adding, removing,
-or updating of specific individual properties or values.
-
-Your response should start with "Modification Plan:" followed by the detailed plan.
+    convoBase.addDeveloperMessage(`
+Before we begin, please provide a detailed plan outlining the specific steps you will take to
+implement the requested modifications to the JSON object. This plan should break down the
+modification instructions into a clear sequence of actions that you will perform, where each
+action corresponds to a specific change in the JSON structure -- either the adding, removing,
+or updating of specific individual properties or values.
+
+Your response should start with "Modification Plan:" followed by the detailed plan.
 `);
     await convoBase.submit();
-    convoBase.addSystemMessage(`
-NAVIGATING THE JSON OBJECT AND JSON PATHS
-
-You have probably already noticed that the JSON object is annotated with placemarks
-(comments) to indicate the positions of objects and indexes for better readability.
-The syntax of these placemarks is quite straightforward, as it follows JavaScript/TypeScript
-notation for accessing properties and array elements.
-
-E.g. root["items"][0]["keywords"][1] refers to the second element of the "keywords" array
-of the first element of the "items" array in the root object.
-
-When prompted for a location in the JSON object, you'll emit a JSON list that corresponds
-to the path to that location, where each element in the list is either a property name (string)
-or an array index (number).
-
-Thus, the path to root["items"][0]["keywords"][1] would be represented as:
-json_path = ["items", 0, "keywords", 1]
+    convoBase.addSystemMessage(`
+NAVIGATING THE JSON OBJECT AND JSON PATHS
+
+You have probably already noticed that the JSON object is annotated with placemarks
+(comments) to indicate the positions of objects and indexes for better readability.
+The syntax of these placemarks is quite straightforward, as it follows JavaScript/TypeScript
+notation for accessing properties and array elements.
+
+E.g. root["items"][0]["keywords"][1] refers to the second element of the "keywords" array
+of the first element of the "items" array in the root object.
+
+When prompted for a location in the JSON object, you'll emit a JSON list that corresponds
+to the path to that location, where each element in the list is either a property name (string)
+or an array index (number).
+
+Thus, the path to root["items"][0]["keywords"][1] would be represented as:
+json_path = ["items", 0, "keywords", 1]
 `);
-    convoBase.addSystemMessage(`
-INSTRUCTIONS FOR MODIFICATION OPERATIONS
-
-You will be implementing the modification plan through a series of modification operations.
-By incrementally applying these operations, we will arrive at the final modified JSON object that
-satisfies the modification instructions.
-
-We will be permitted to take multiple passes over the JSON object, and make multiple
-modifications, so don't feel obligated to get everything right in the first few steps.
-We will have plenty of opportunities to iteratively develop the final result. Your initial list
-of operations to execute doesn't necessarily need to achieve the final result; if it merely
-"walks" towards the final result, that's perfectly fine, as we'll be able to continue to "walk"
-further towards the final result in subsequent iterations.
-
-Structure of a Modification Operation:
-
-- **json_path_of_parent**: A JSON path indicating the location in the JSON object where the
-    modification should be applied. We call this the "parent" location because we specify
-    the key or index within the parent later. For example, if you want to set the string
-    property "foo" to the value "bar" on the root object (i.e. root["foo"]="bar"), then
-    json_path_of_parent would be an empty list [], since the parent of "foo" is the root object.
-    If you want to append a new string value into the "keywords" array of the first
-    element of the "items" array (i.e. root["items"][0]["keywords"].push("new_keyword")), then
-    json_path_of_parent would be ["items", 0, "keywords"], since the parent of the new element
-    is the "keywords" array itself. The syntax of the json_path should follow the same notation
-    as described in the "Navigating the JSON Object and JSON Paths" section above.
-
-- **key_or_index**: The key (string) or array index (number) of the property or element to modify.
-    If the parent location (json_path_of_parent) is an object, then this will be a string key.
-    If the parent location is an array, then this will be a numeric index.
-    SPECIAL: If you're using the "append" action (see below) to add a new element to the end of
-    an array, then key_or_index is ignored; set it to -1 to indicate to yourself that it's
-    irrelevant.
-
-- **action**: The type of modification to perform. This can be one of the following values:
-    - "delete": Delete the specified property or array element. (The "data" field is ignored,
-        and should be set to null.) This "delete" action is functionally equivalent to
-        \`delete parent[key]\` for objects, or \`parent.splice(index, 1)\` for arrays.
-    - "assign": Set the property or element to a new value. If the parent is an array, then the
-        "assign" action will replace the existing element at the specified index. If the parent
-        is an object, then the "assign" action will set the value of the specified key, replacing
-        any existing value for that key if it already exists, or creating a new key-value pair if
-        the key does not already exist. This is functionally equivalent to:
-            \`parent[key] = data\` for objects, or
-            \`parent[index] = data\` for arrays.
-    - "append": Applicable only when the parent object is an array. Append a new element to the
-        end of the array. The "key_or_index" field is ignored. This is functionally equivalent to:
-            \`parent.push(data)\`.
-    - "insert": Applicable only when the parent object is an array. Insert a new element at the
-        specified index in the array. This is functionally equivalent to:
-            \`parent.splice(index, 0, data)\`.
-    - "rename": Applicable only when the parent object is an object. Rename a property from the
-        old key name (specified in "key_or_index") to a new key name. The "new_key_name" field
-        (see below) *must* be provided. The "data" field is ignored for this action; you should
-        just set it to null. This is functionally equivalent to:
-            \`parent[new_key_name] = parent[key_or_index]; delete parent[key_or_index]\`.
-
-- **new_key_name**: Applicable only for the "rename" action. This field specifies the new key name
-    to rename a property to. For all other actions, this field is ignored and should just be set
-    to an empty string.
-
-- **data**: The new value to set for "assign", "append", or "insert" actions. This field comes in
-    the following forms:
-
-    - **null**: You should set the data field to null when the action does not require a value,
-        such as "delete" or "rename". For all other actions, the data field cannot be null.
-
-    - **inline_value**: You explicitly write out the value to set. The value you construct will be
-        one of the following:
-        - A primitive value (string, number, boolean, null)
-        - An empty object ({}). This is useful for gradually building up complex objects through
-            a series of subsequent modifications.
-        - An empty array ([]). This is useful for gradually building up complex collections
-            through a series of subsequent modifications.
-        - An array whose elements are all either primitive values or empty objects/arrays. This is
-            useful for adding multiple related elements at once. If the array contains empty
-            objects/arrays, you can fill these in with actual values in subsequent modifications,
-            if needed.
-        - An object whose values are all either primitive values or empty objects/arrays. Again,
-            just like with arrays, if the object contains empty objects/arrays, you can fill these
-            in with actual values in subsequent modifications, if needed.
-        Note that "value" cannot recursively describe deeply nested structures in one step; it can
-        only describe at most a single layer of nesting. That's okay; you can build up complex
-        nested structures through a series of modifications, gradually filling in more and more
-        details with each modification. Just make sure to provide detailed notes about your plans
-        and intentions with each modification, so that we can keep track of the overall plan and
-        ensure that we're on the right track.
-
-    - **json_path_of_copy_source**: If you need to construct a deeply nested object, and there
-        happens to be a source object or array elsewhere in the JSON that already has a very
-        similar (or identical) structure, you can specify the JSON path to that source object
-        or array here. This can be a handy shortcut for creating complex structures without
-        having to manually specify every detail. PRO TIP: This is also a great way to **move**
-        existing structures around within the JSON, by copying from one path and then deleting
-        the original -- this makes moving a structure from one place to another a two-step process
-        instead of a long series of inline_value assignments.
+    convoBase.addSystemMessage(`
+INSTRUCTIONS FOR MODIFICATION OPERATIONS
+
+You will be implementing the modification plan through a series of modification operations.
+By incrementally applying these operations, we will arrive at the final modified JSON object that
+satisfies the modification instructions.
+
+We will be permitted to take multiple passes over the JSON object, and make multiple
+modifications, so don't feel obligated to get everything right in the first few steps.
+We will have plenty of opportunities to iteratively develop the final result. Your initial list
+of operations to execute doesn't necessarily need to achieve the final result; if it merely
+"walks" towards the final result, that's perfectly fine, as we'll be able to continue to "walk"
+further towards the final result in subsequent iterations.
+
+Structure of a Modification Operation:
+
+- **json_path_of_parent**: A JSON path indicating the location in the JSON object where the
+    modification should be applied. We call this the "parent" location because we specify
+    the key or index within the parent later. For example, if you want to set the string
+    property "foo" to the value "bar" on the root object (i.e. root["foo"]="bar"), then
+    json_path_of_parent would be an empty list [], since the parent of "foo" is the root object.
+    If you want to append a new string value into the "keywords" array of the first
+    element of the "items" array (i.e. root["items"][0]["keywords"].push("new_keyword")), then
+    json_path_of_parent would be ["items", 0, "keywords"], since the parent of the new element
+    is the "keywords" array itself. The syntax of the json_path should follow the same notation
+    as described in the "Navigating the JSON Object and JSON Paths" section above.
+
+- **key_or_index**: The key (string) or array index (number) of the property or element to modify.
+    If the parent location (json_path_of_parent) is an object, then this will be a string key.
+    If the parent location is an array, then this will be a numeric index.
+    SPECIAL: If you're using the "append" action (see below) to add a new element to the end of
+    an array, then key_or_index is ignored; set it to -1 to indicate to yourself that it's
+    irrelevant.
+
+- **action**: The type of modification to perform. This can be one of the following values:
+    - "delete": Delete the specified property or array element. (The "data" field is ignored,
+        and should be set to null.) This "delete" action is functionally equivalent to
+        \`delete parent[key]\` for objects, or \`parent.splice(index, 1)\` for arrays.
+    - "assign": Set the property or element to a new value. If the parent is an array, then the
+        "assign" action will replace the existing element at the specified index. If the parent
+        is an object, then the "assign" action will set the value of the specified key, replacing
+        any existing value for that key if it already exists, or creating a new key-value pair if
+        the key does not already exist. This is functionally equivalent to:
+            \`parent[key] = data\` for objects, or
+            \`parent[index] = data\` for arrays.
+    - "append": Applicable only when the parent object is an array. Append a new element to the
+        end of the array. The "key_or_index" field is ignored. This is functionally equivalent to:
+            \`parent.push(data)\`.
+    - "insert": Applicable only when the parent object is an array. Insert a new element at the
+        specified index in the array. This is functionally equivalent to:
+            \`parent.splice(index, 0, data)\`.
+    - "rename": Applicable only when the parent object is an object. Rename a property from the
+        old key name (specified in "key_or_index") to a new key name. The "new_key_name" field
+        (see below) *must* be provided. The "data" field is ignored for this action; you should
+        just set it to null. This is functionally equivalent to:
+            \`parent[new_key_name] = parent[key_or_index]; delete parent[key_or_index]\`.
+
+- **new_key_name**: Applicable only for the "rename" action. This field specifies the new key name
+    to rename a property to. For all other actions, this field is ignored and should just be set
+    to an empty string.
+
+- **data**: The new value to set for "assign", "append", or "insert" actions. This field comes in
+    the following forms:
+
+    - **null**: You should set the data field to null when the action does not require a value,
+        such as "delete" or "rename". For all other actions, the data field cannot be null.
+
+    - **inline_value**: You explicitly write out the value to set. The value you construct will be
+        one of the following:
+        - A primitive value (string, number, boolean, null)
+        - An empty object ({}). This is useful for gradually building up complex objects through
+            a series of subsequent modifications.
+        - An empty array ([]). This is useful for gradually building up complex collections
+            through a series of subsequent modifications.
+        - An array whose elements are all either primitive values or empty objects/arrays. This is
+            useful for adding multiple related elements at once. If the array contains empty
+            objects/arrays, you can fill these in with actual values in subsequent modifications,
+            if needed.
+        - An object whose values are all either primitive values or empty objects/arrays. Again,
+            just like with arrays, if the object contains empty objects/arrays, you can fill these
+            in with actual values in subsequent modifications, if needed.
+        Note that "value" cannot recursively describe deeply nested structures in one step; it can
+        only describe at most a single layer of nesting. That's okay; you can build up complex
+        nested structures through a series of modifications, gradually filling in more and more
+        details with each modification. Just make sure to provide detailed notes about your plans
+        and intentions with each modification, so that we can keep track of the overall plan and
+        ensure that we're on the right track.
+
+    - **json_path_of_copy_source**: If you need to construct a deeply nested object, and there
+        happens to be a source object or array elsewhere in the JSON that already has a very
+        similar (or identical) structure, you can specify the JSON path to that source object
+        or array here. This can be a handy shortcut for creating complex structures without
+        having to manually specify every detail. PRO TIP: This is also a great way to **move**
+        existing structures around within the JSON, by copying from one path and then deleting
+        the original -- this makes moving a structure from one place to another a two-step process
+        instead of a long series of inline_value assignments.
 `);
     convoBase.addDeveloperMessage(`Alrighty then. Let's get to work!`);
     const operationsDoneSoFar = [];
@@ -368,74 +368,74 @@ Structure of a Modification Operation:
                 numIterations > options.giveUpAfterIterations) {
                 throw new JSONSurgeryError(`Giving up after ${options.giveUpAfterIterations}. Maximum iterations reached. `, obj);
             }
-            convo.addUserMessage(`
-CURRENT STATUS:
-We've been processing for ${secondsElapsed} seconds.
-We've performed ${operationsDoneSoFar.length} operations across ${numIterations - 1} iterations.
+            convo.addUserMessage(`
+CURRENT STATUS:
+We've been processing for ${secondsElapsed} seconds.
+We've performed ${operationsDoneSoFar.length} operations across ${numIterations - 1} iterations.
 `);
             if (operationsDoneSoFar.length > 0) {
                 let msgOpsSoFar = ``;
                 for (let i = 0; i < operationsDoneSoFar.length; i++) {
                     msgOpsSoFar += `${i + 1}. ${operationsDoneSoFar[i]}\n`;
                 }
-                convo.addUserMessage(`
-Here are the operations that we've performed so far:
-${msgOpsSoFar}
+                convo.addUserMessage(`
+Here are the operations that we've performed so far:
+${msgOpsSoFar}
 `);
             }
             convo.addUserMessage({
                 role: 'user',
-                content: `
-Here is the JSON object in its current state, with our modifications up to this point applied.
-
----
-
-${placemarkedJSONStringify(obj, 2, options.skippedKeys)}
+                content: `
+Here is the JSON object in its current state, with our modifications up to this point applied.
+
+---
+
+${placemarkedJSONStringify(obj, 2, options.skippedKeys)}
 `,
             });
             convo.addUserMessage({
                 role: 'user',
-                content: `
-Just to help re-establish context from previous iterations, here is the last operation we
-performed on this JSON object:
-${operationLast}
-
-Here's what we were planning to do next:
-${operationNext}
+                content: `
+Just to help re-establish context from previous iterations, here is the last operation we
+performed on this JSON object:
+${operationLast}
+
+Here's what we were planning to do next:
+${operationNext}
 `,
             });
             if (!operationLastWasSuccessful) {
                 convo.addDeveloperMessage({
                     role: 'user',
-                    content: `
-!CRITICAL: The last operation we attempted FAILED! DO NOT DO THE SAME OPERATION AGAIN!
-Think of a *different* operation to perform. Think of a different *way* to perform
-the modifications that we need to make. Break them up over different steps, or
-re-think your approach, or SOMETHING. Just DO NOT keep trying to do the same thing
-over and over again expecting a different result.
+                    content: `
+!CRITICAL: The last operation we attempted FAILED! DO NOT DO THE SAME OPERATION AGAIN!
+Think of a *different* operation to perform. Think of a different *way* to perform
+the modifications that we need to make. Break them up over different steps, or
+re-think your approach, or SOMETHING. Just DO NOT keep trying to do the same thing
+over and over again expecting a different result.
 `,
                 });
             }
         }
-        convo.addDeveloperMessage(`
-Refer to the "Instructions for Modification Operations" section above for the
-structure of a modification operation.
-
-Based on the overall modification plan and the current state of the JSON object,
-determine and describe the next modifications to apply to the JSON object. Your
-output for now should just be plain English. Later, when I ask you to, you'll
-formalize it into a JSON object -- but for now, just talk your way through it.
-
-If the modification instructions require multiple changes to the JSON object, you can describe
-multiple modifications to apply in this step. You can also break down a complex modification into
-a series of simpler modifications that can be applied incrementally, if that makes it easier to
-implement the overall modification instructions correctly. Just make sure to be very clear and
-detailed in describing your intended modifications, so that we can ensure that we're on the
-right track and that the modifications you propose are correctly implementing the modification
-instructions.
-
-If the modification instructions have already been fully satisfied and no further modifications
-are needed, then just say that we're done and don't propose any further modifications.
+        convo.addDeveloperMessage(`
+Refer to the "Instructions for Modification Operations" section above for the
+structure of a modification operation.
+
+Based on the overall modification plan and the current state of the JSON object,
+determine and describe the next modifications to apply to the JSON object. Your
+output for now should just be plain English. Later, when I ask you to, you'll
+formalize it into a JSON object -- but for now, just talk your way through it.
+
+If the modification instructions require multiple changes to the JSON object, you can describe
+multiple modifications to apply in this step. You can also break down a complex modification into
+a series of simpler modifications that can be applied incrementally, if that makes it easier to
+implement the overall modification instructions correctly. Just make sure to be very clear and
+detailed in describing your intended modifications, so that we can ensure that we're on the
+right track and that the modifications you propose are correctly implementing the modification
+instructions.
+
+If the modification instructions have already been fully satisfied and no further modifications
+are needed, then just say that we're done and don't propose any further modifications.
 `);
         await convo.submit();
         await convo.submit(undefined, undefined, {
@@ -443,12 +443,12 @@ are needed, then just say that we're done and don't propose any further modifica
                 format: {
                     type: 'json_schema',
                     name: 'json_object_modifications',
-                    description: `
-A JSON formalization of the next set of modifications to apply to the JSON object,
-as we have just determined and described. If there are multiple modifications to apply,
-you can include all of them in this JSON object. If there are no modifications to apply
-because the modification instructions have already been fully satisfied, then set the
-"modifications" field to an empty list.
+                    description: `
+A JSON formalization of the next set of modifications to apply to the JSON object,
+as we have just determined and described. If there are multiple modifications to apply,
+you can include all of them in this JSON object. If there are no modifications to apply
+because the modification instructions have already been fully satisfied, then set the
+"modifications" field to an empty list.
 `,
                     schema: {
                         type: 'object',
@@ -478,19 +478,19 @@ because the modification instructions have already been fully satisfied, then se
                                                     properties: {
                                                         inline_value: {
                                                             ...JSON_SCHEMA_SET_VALUE,
-                                                            description: `
-The new value to set for "assign", "append", or "insert" actions.
-For "delete" and "rename" actions, this field is ignored and should be set to null.
-This can be one of the following:
-- A primitive value (string, number, boolean, null)
-- An empty object ({}).
-- An empty array ([]).
-- An array whose elements are all either primitive values or empty objects/arrays.
-- An object(*) whose values are all either primitive values or empty objects/arrays.
-(*) NOTE: Due to some limitations in our JSON schema processor, we cannot have you
-provide an object with arbitrary keys directly. Instead, please provide an array of
-key-value pair objects. I know it *looks like* an array, but we'll interpret it as
-an object.
+                                                            description: `
+The new value to set for "assign", "append", or "insert" actions.
+For "delete" and "rename" actions, this field is ignored and should be set to null.
+This can be one of the following:
+- A primitive value (string, number, boolean, null)
+- An empty object ({}).
+- An empty array ([]).
+- An array whose elements are all either primitive values or empty objects/arrays.
+- An object(*) whose values are all either primitive values or empty objects/arrays.
+(*) NOTE: Due to some limitations in our JSON schema processor, we cannot have you
+provide an object with arbitrary keys directly. Instead, please provide an array of
+key-value pair objects. I know it *looks like* an array, but we'll interpret it as
+an object.
 `,
                                                         },
                                                     },
@@ -552,16 +552,16 @@ an object.
             }
             // Kick it back for further processing.
             operationLastWasSuccessful = false;
-            let actionDesc = `
-ERROR: Validation failure on attempted exit.
-We thought we had finished processing, but the object didn't pass an automated
-validation check. This is often the result of undocumented requirements,
-and isn't necessarily because you did anything wrong. Nonetheless, these remaining
-issues must be addressed before we can consider the object valid.)
-
-The validator returned the following errors:
-
-- ${validationErrors.join('\n -')}
+            let actionDesc = `
+ERROR: Validation failure on attempted exit.
+We thought we had finished processing, but the object didn't pass an automated
+validation check. This is often the result of undocumented requirements,
+and isn't necessarily because you did anything wrong. Nonetheless, these remaining
+issues must be addressed before we can consider the object valid.)
+
+The validator returned the following errors:
+
+- ${validationErrors.join('\n -')}
 `;
             operationsDoneSoFar.push(actionDesc);
             operationLast = actionDesc;
@@ -649,67 +649,67 @@ The validator returned the following errors:
                 else {
                     throw new Error(`Unknown action: ${action}`);
                 }
-                convo.addSystemMessage(`
-The following modification was applied to the JSON object without any errors:
-
-json_path_of_parent: ${JSON.stringify(json_path_of_parent)}
-key_or_index: ${JSON.stringify(key_or_index)}
-action: ${JSON.stringify(action)}
-new_key_name: ${JSON.stringify(new_key_name)}
-value: ${JSON.stringify(value, null, 2)}
+                convo.addSystemMessage(`
+The following modification was applied to the JSON object without any errors:
+
+json_path_of_parent: ${JSON.stringify(json_path_of_parent)}
+key_or_index: ${JSON.stringify(key_or_index)}
+action: ${JSON.stringify(action)}
+new_key_name: ${JSON.stringify(new_key_name)}
+value: ${JSON.stringify(value, null, 2)}
 `);
             }
             catch (error) {
-                convo.addSystemMessage(`
-An error occurred while attempting to apply the proposed modification:
-${error.message}
+                convo.addSystemMessage(`
+An error occurred while attempting to apply the proposed modification:
+${error.message}
 `);
             }
         }
         // Verify the modified object with the LLM
-        convo.addUserMessage(`
-Here is the JSON object after applying the proposed modification.
-
----
-
-${placemarkedJSONStringify(objModified, 2, options.skippedKeys)}
+        convo.addUserMessage(`
+Here is the JSON object after applying the proposed modification.
+
+---
+
+${placemarkedJSONStringify(objModified, 2, options.skippedKeys)}
 `);
-        convo.addDeveloperMessage(`
-Examining the modified JSON object after the proposed modifications have been applied,
-let's discuss and analyze whether or not these modifications are correct, i.e. whether
-or not they properly implement the intended changes.
-
-Specifically, check the following:
-
-- Does the modified JSON object now correctly contain the modifications?
-
-- Does the modified JSON object contain any unintended changes? This typically results from
-    one or more poorly structured modification objects, where json_path_of_parent point to
-    the wrong location in the JSON object.
-
-- Are the modifications *correct but incomplete*? In other words, were the modifications
-    that were applied correct in the sense that they were consistent with the modification
-    instructions, but they only represent one step in a multi-step process? If so, then this
-    is not a problem at all. We will continue to apply more modifications in subsequent
-    iterations.
-
-At the end of your analysis, write a conclusion. Your conclusion should be one of the
-following, or some variant thereof:
-
-- The changes are correct and complete for this step in the modification process.
-    We can keep them, and we can move on to the next step in the modification process.
-
-- The changes are correct but incomplete for this step in the modification process.
-    They are consistent with the modification instructions, but they only represent one step
-    in a multi-step process. This is not a problem at all. We will keep these changes,
-    and we will continue to apply more modifications in subsequent iterations,
-    to make further progress towards satisfying the modification instructions.
-
-- The changes are incorrect for this step in the modification process. They do not progress
-    us towards satisfying the modification instructions, and they may even break things and
-    take us further away from satisfying the modification instructions. We should reject these
-    changes, revert back to the previous version of the JSON object, and try a different
-    modification operation that is more likely to be correct.
+        convo.addDeveloperMessage(`
+Examining the modified JSON object after the proposed modifications have been applied,
+let's discuss and analyze whether or not these modifications are correct, i.e. whether
+or not they properly implement the intended changes.
+
+Specifically, check the following:
+
+- Does the modified JSON object now correctly contain the modifications?
+
+- Does the modified JSON object contain any unintended changes? This typically results from
+    one or more poorly structured modification objects, where json_path_of_parent point to
+    the wrong location in the JSON object.
+
+- Are the modifications *correct but incomplete*? In other words, were the modifications
+    that were applied correct in the sense that they were consistent with the modification
+    instructions, but they only represent one step in a multi-step process? If so, then this
+    is not a problem at all. We will continue to apply more modifications in subsequent
+    iterations.
+
+At the end of your analysis, write a conclusion. Your conclusion should be one of the
+following, or some variant thereof:
+
+- The changes are correct and complete for this step in the modification process.
+    We can keep them, and we can move on to the next step in the modification process.
+
+- The changes are correct but incomplete for this step in the modification process.
+    They are consistent with the modification instructions, but they only represent one step
+    in a multi-step process. This is not a problem at all. We will keep these changes,
+    and we will continue to apply more modifications in subsequent iterations,
+    to make further progress towards satisfying the modification instructions.
+
+- The changes are incorrect for this step in the modification process. They do not progress
+    us towards satisfying the modification instructions, and they may even break things and
+    take us further away from satisfying the modification instructions. We should reject these
+    changes, revert back to the previous version of the JSON object, and try a different
+    modification operation that is more likely to be correct.
 `);
         await convo.submit();
         await convo.submit(undefined, undefined, {
@@ -717,9 +717,9 @@ following, or some variant thereof:
                 format: {
                     type: 'json_schema',
                     name: 'modification_verification',
-                    description: `
-A JSON formalization of the analysis and verification of the modifications that were just applied
-to the JSON object, as we have just discussed and analyzed.
+                    description: `
+A JSON formalization of the analysis and verification of the modifications that were just applied
+to the JSON object, as we have just discussed and analyzed.
 `,
                     schema: {
                         type: 'object',