@polka-codes/cli-shared 0.9.39 → 0.9.40

package/dist/index.js

@@ -4974,7 +4974,7 @@ var require_lodash = __commonJS((exports, module) => {
         }
         return func(collection, getIteratee(predicate, 3));
       }
-      function filter2(collection, predicate) {
+      function filter3(collection, predicate) {
         var func = isArray(collection) ? arrayFilter : baseFilter;
         return func(collection, getIteratee(predicate, 3));
       }
@@ -6390,7 +6390,7 @@ __p += '`;
       lodash.dropRightWhile = dropRightWhile;
       lodash.dropWhile = dropWhile;
       lodash.fill = fill;
-      lodash.filter = filter2;
+      lodash.filter = filter3;
       lodash.flatMap = flatMap;
       lodash.flatMapDeep = flatMapDeep;
       lodash.flatMapDepth = flatMapDepth;
@@ -15266,124 +15266,6 @@ var require_lib = __commonJS((exports, module) => {
   module.exports = MuteStream;
 });
 
-// ../../node_modules/ansi-escapes/index.js
-var require_ansi_escapes = __commonJS((exports, module) => {
-  var ansiEscapes = exports;
-  exports.default = ansiEscapes;
-  var ESC = "\x1B[";
-  var OSC = "\x1B]";
-  var BEL = "\x07";
-  var SEP = ";";
-  var isTerminalApp = process.env.TERM_PROGRAM === "Apple_Terminal";
-  ansiEscapes.cursorTo = (x, y) => {
-    if (typeof x !== "number") {
-      throw new TypeError("The `x` argument is required");
-    }
-    if (typeof y !== "number") {
-      return ESC + (x + 1) + "G";
-    }
-    return ESC + (y + 1) + ";" + (x + 1) + "H";
-  };
-  ansiEscapes.cursorMove = (x, y) => {
-    if (typeof x !== "number") {
-      throw new TypeError("The `x` argument is required");
-    }
-    let ret = "";
-    if (x < 0) {
-      ret += ESC + -x + "D";
-    } else if (x > 0) {
-      ret += ESC + x + "C";
-    }
-    if (y < 0) {
-      ret += ESC + -y + "A";
-    } else if (y > 0) {
-      ret += ESC + y + "B";
-    }
-    return ret;
-  };
-  ansiEscapes.cursorUp = (count = 1) => ESC + count + "A";
-  ansiEscapes.cursorDown = (count = 1) => ESC + count + "B";
-  ansiEscapes.cursorForward = (count = 1) => ESC + count + "C";
-  ansiEscapes.cursorBackward = (count = 1) => ESC + count + "D";
-  ansiEscapes.cursorLeft = ESC + "G";
-  ansiEscapes.cursorSavePosition = isTerminalApp ? "\x1B7" : ESC + "s";
-  ansiEscapes.cursorRestorePosition = isTerminalApp ? "\x1B8" : ESC + "u";
-  ansiEscapes.cursorGetPosition = ESC + "6n";
-  ansiEscapes.cursorNextLine = ESC + "E";
-  ansiEscapes.cursorPrevLine = ESC + "F";
-  ansiEscapes.cursorHide = ESC + "?25l";
-  ansiEscapes.cursorShow = ESC + "?25h";
-  ansiEscapes.eraseLines = (count) => {
-    let clear = "";
-    for (let i = 0;i < count; i++) {
-      clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : "");
-    }
-    if (count) {
-      clear += ansiEscapes.cursorLeft;
-    }
-    return clear;
-  };
-  ansiEscapes.eraseEndLine = ESC + "K";
-  ansiEscapes.eraseStartLine = ESC + "1K";
-  ansiEscapes.eraseLine = ESC + "2K";
-  ansiEscapes.eraseDown = ESC + "J";
-  ansiEscapes.eraseUp = ESC + "1J";
-  ansiEscapes.eraseScreen = ESC + "2J";
-  ansiEscapes.scrollUp = ESC + "S";
-  ansiEscapes.scrollDown = ESC + "T";
-  ansiEscapes.clearScreen = "\x1Bc";
-  ansiEscapes.clearTerminal = process.platform === "win32" ? `${ansiEscapes.eraseScreen}${ESC}0f` : `${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
-  ansiEscapes.beep = BEL;
-  ansiEscapes.link = (text2, url2) => {
-    return [
-      OSC,
-      "8",
-      SEP,
-      SEP,
-      url2,
-      BEL,
-      text2,
-      OSC,
-      "8",
-      SEP,
-      SEP,
-      BEL
-    ].join("");
-  };
-  ansiEscapes.image = (buffer, options = {}) => {
-    let ret = `${OSC}1337;File=inline=1`;
-    if (options.width) {
-      ret += `;width=${options.width}`;
-    }
-    if (options.height) {
-      ret += `;height=${options.height}`;
-    }
-    if (options.preserveAspectRatio === false) {
-      ret += ";preserveAspectRatio=0";
-    }
-    return ret + ":" + buffer.toString("base64") + BEL;
-  };
-  ansiEscapes.iTerm = {
-    setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
-    annotation: (message, options = {}) => {
-      let ret = `${OSC}1337;`;
-      const hasX = typeof options.x !== "undefined";
-      const hasY = typeof options.y !== "undefined";
-      if ((hasX || hasY) && !(hasX && hasY && typeof options.length !== "undefined")) {
-        throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
-      }
-      message = message.replace(/\|/g, "");
-      ret += options.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
-      if (options.length > 0) {
-        ret += (hasX ? [message, options.length, options.x, options.y] : [options.length, message]).join("|");
-      } else {
-        ret += message;
-      }
-      return ret + BEL;
-    }
-  };
-});
-
 // ../../node_modules/ignore/index.js
 var require_ignore = __commonJS((exports, module) => {
   function makeArray(subject) {
@@ -37030,16 +36912,18 @@ var toolInfo = {
       {
         description: "Single clarifying question (no options)",
         input: {
-          questions: { prompt: "What is the target deployment environment?" }
+          questions: [{ prompt: "What is the target deployment environment?" }]
         }
       },
       {
         description: "Single question with multiple-choice options",
         input: {
-          questions: {
-            prompt: "Which frontend framework are you using?",
-            options: ["React", "Angular", "Vue", "Svelte"]
-          }
+          questions: [
+            {
+              prompt: "Which frontend framework are you using?",
+              options: ["React", "Angular", "Vue", "Svelte"]
+            }
+          ]
         }
       },
       {
@@ -37057,10 +36941,12 @@ var toolInfo = {
       {
         description: "Binary (yes/no) confirmation",
         input: {
-          questions: {
-            prompt: "Is it acceptable to refactor existing tests to improve performance?",
-            options: ["Yes", "No"]
-          }
+          questions: [
+            {
+              prompt: "Is it acceptable to refactor existing tests to improve performance?",
+              options: ["Yes", "No"]
+            }
+          ]
         }
       }
     ]
@@ -42482,13 +42368,7 @@ var optionalType = ZodOptional2.create;
 var nullableType = ZodNullable2.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
-// ../../node_modules/@ai-sdk/provider-utils/dist/index.mjs
-function combineHeaders(...headers) {
-  return headers.reduce((combinedHeaders, currentHeaders) => ({
-    ...combinedHeaders,
-    ...currentHeaders != null ? currentHeaders : {}
-  }), {});
-}
+// ../../node_modules/ai/node_modules/@ai-sdk/provider-utils/dist/index.mjs
 async function delay(delayInMs, options) {
   if (delayInMs == null) {
     return Promise.resolve();
@@ -42517,9 +42397,6 @@ async function delay(delayInMs, options) {
 function createAbortError() {
   return new DOMException("Delay was aborted", "AbortError");
 }
-function extractResponseHeaders(response) {
-  return Object.fromEntries([...response.headers]);
-}
 var createIdGenerator = ({
   prefix,
   size = 16,
@@ -42561,96 +42438,6 @@ function getErrorMessage2(error43) {
 function isAbortError(error43) {
   return (error43 instanceof Error || error43 instanceof DOMException) && (error43.name === "AbortError" || error43.name === "ResponseAborted" || error43.name === "TimeoutError");
 }
-var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
-function handleFetchError({
-  error: error43,
-  url: url2,
-  requestBodyValues
-}) {
-  if (isAbortError(error43)) {
-    return error43;
-  }
-  if (error43 instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error43.message.toLowerCase())) {
-    const cause = error43.cause;
-    if (cause != null) {
-      return new APICallError({
-        message: `Cannot connect to API: ${cause.message}`,
-        cause,
-        url: url2,
-        requestBodyValues,
-        isRetryable: true
-      });
-    }
-  }
-  return error43;
-}
-function removeUndefinedEntries(record2) {
-  return Object.fromEntries(Object.entries(record2).filter(([_key, value]) => value != null));
-}
-var getOriginalFetch = () => globalThis.fetch;
-var getFromApi = async ({
-  url: url2,
-  headers = {},
-  successfulResponseHandler,
-  failedResponseHandler,
-  abortSignal,
-  fetch: fetch2 = getOriginalFetch()
-}) => {
-  try {
-    const response = await fetch2(url2, {
-      method: "GET",
-      headers: removeUndefinedEntries(headers),
-      signal: abortSignal
-    });
-    const responseHeaders = extractResponseHeaders(response);
-    if (!response.ok) {
-      let errorInformation;
-      try {
-        errorInformation = await failedResponseHandler({
-          response,
-          url: url2,
-          requestBodyValues: {}
-        });
-      } catch (error43) {
-        if (isAbortError(error43) || APICallError.isInstance(error43)) {
-          throw error43;
-        }
-        throw new APICallError({
-          message: "Failed to process error response",
-          cause: error43,
-          statusCode: response.status,
-          url: url2,
-          responseHeaders,
-          requestBodyValues: {}
-        });
-      }
-      throw errorInformation.value;
-    }
-    try {
-      return await successfulResponseHandler({
-        response,
-        url: url2,
-        requestBodyValues: {}
-      });
-    } catch (error43) {
-      if (error43 instanceof Error) {
-        if (isAbortError(error43) || APICallError.isInstance(error43)) {
-          throw error43;
-        }
-      }
-      throw new APICallError({
-        message: "Failed to process successful response",
-        cause: error43,
-        statusCode: response.status,
-        url: url2,
-        responseHeaders,
-        requestBodyValues: {}
-      });
-    }
-  } catch (error43) {
-    throw handleFetchError({ error: error43, url: url2, requestBodyValues: {} });
-  }
-};
 function isUrlSupported({
   mediaType,
   url: url2,
@@ -42663,22 +42450,6 @@ function isUrlSupported({
     return mediaType2 === "*" || mediaType2 === "*/*" ? { mediaTypePrefix: "", regexes: value } : { mediaTypePrefix: mediaType2.replace(/\*/, ""), regexes: value };
   }).filter(({ mediaTypePrefix }) => mediaType.startsWith(mediaTypePrefix)).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url2));
 }
-function loadOptionalSetting({
-  settingValue,
-  environmentVariableName
-}) {
-  if (typeof settingValue === "string") {
-    return settingValue;
-  }
-  if (settingValue != null || typeof process === "undefined") {
-    return;
-  }
-  settingValue = process.env[environmentVariableName];
-  if (settingValue == null || typeof settingValue !== "string") {
-    return;
-  }
-  return settingValue;
-}
 var suspectProtoRx = /"__proto__"\s*:/;
 var suspectConstructorRx = /"constructor"\s*:/;
 function _parse2(text) {
@@ -42780,23 +42551,6 @@ async function safeValidateTypes({
     };
   }
 }
-async function parseJSON({
-  text,
-  schema
-}) {
-  try {
-    const value = secureJsonParse(text);
-    if (schema == null) {
-      return value;
-    }
-    return validateTypes({ value, schema });
-  } catch (error43) {
-    if (JSONParseError.isInstance(error43) || TypeValidationError.isInstance(error43)) {
-      throw error43;
-    }
-    throw new JSONParseError({ text, cause: error43 });
-  }
-}
 async function safeParseJSON({
   text,
   schema
@@ -42815,205 +42569,6 @@ async function safeParseJSON({
     };
   }
 }
-function parseJsonEventStream({
-  stream,
-  schema
-}) {
-  return stream.pipeThrough(new TextDecoderStream).pipeThrough(new EventSourceParserStream).pipeThrough(new TransformStream({
-    async transform({ data }, controller) {
-      if (data === "[DONE]") {
-        return;
-      }
-      controller.enqueue(await safeParseJSON({ text: data, schema }));
-    }
-  }));
-}
-var getOriginalFetch2 = () => globalThis.fetch;
-var postJsonToApi = async ({
-  url: url2,
-  headers,
-  body,
-  failedResponseHandler,
-  successfulResponseHandler,
-  abortSignal,
-  fetch: fetch2
-}) => postToApi({
-  url: url2,
-  headers: {
-    "Content-Type": "application/json",
-    ...headers
-  },
-  body: {
-    content: JSON.stringify(body),
-    values: body
-  },
-  failedResponseHandler,
-  successfulResponseHandler,
-  abortSignal,
-  fetch: fetch2
-});
-var postToApi = async ({
-  url: url2,
-  headers = {},
-  body,
-  successfulResponseHandler,
-  failedResponseHandler,
-  abortSignal,
-  fetch: fetch2 = getOriginalFetch2()
-}) => {
-  try {
-    const response = await fetch2(url2, {
-      method: "POST",
-      headers: removeUndefinedEntries(headers),
-      body: body.content,
-      signal: abortSignal
-    });
-    const responseHeaders = extractResponseHeaders(response);
-    if (!response.ok) {
-      let errorInformation;
-      try {
-        errorInformation = await failedResponseHandler({
-          response,
-          url: url2,
-          requestBodyValues: body.values
-        });
-      } catch (error43) {
-        if (isAbortError(error43) || APICallError.isInstance(error43)) {
-          throw error43;
-        }
-        throw new APICallError({
-          message: "Failed to process error response",
-          cause: error43,
-          statusCode: response.status,
-          url: url2,
-          responseHeaders,
-          requestBodyValues: body.values
-        });
-      }
-      throw errorInformation.value;
-    }
-    try {
-      return await successfulResponseHandler({
-        response,
-        url: url2,
-        requestBodyValues: body.values
-      });
-    } catch (error43) {
-      if (error43 instanceof Error) {
-        if (isAbortError(error43) || APICallError.isInstance(error43)) {
-          throw error43;
-        }
-      }
-      throw new APICallError({
-        message: "Failed to process successful response",
-        cause: error43,
-        statusCode: response.status,
-        url: url2,
-        responseHeaders,
-        requestBodyValues: body.values
-      });
-    }
-  } catch (error43) {
-    throw handleFetchError({ error: error43, url: url2, requestBodyValues: body.values });
-  }
-};
-async function resolve(value) {
-  if (typeof value === "function") {
-    value = value();
-  }
-  return Promise.resolve(value);
-}
-var createJsonErrorResponseHandler = ({
-  errorSchema,
-  errorToMessage,
-  isRetryable
-}) => async ({ response, url: url2, requestBodyValues }) => {
-  const responseBody = await response.text();
-  const responseHeaders = extractResponseHeaders(response);
-  if (responseBody.trim() === "") {
-    return {
-      responseHeaders,
-      value: new APICallError({
-        message: response.statusText,
-        url: url2,
-        requestBodyValues,
-        statusCode: response.status,
-        responseHeaders,
-        responseBody,
-        isRetryable: isRetryable == null ? undefined : isRetryable(response)
-      })
-    };
-  }
-  try {
-    const parsedError = await parseJSON({
-      text: responseBody,
-      schema: errorSchema
-    });
-    return {
-      responseHeaders,
-      value: new APICallError({
-        message: errorToMessage(parsedError),
-        url: url2,
-        requestBodyValues,
-        statusCode: response.status,
-        responseHeaders,
-        responseBody,
-        data: parsedError,
-        isRetryable: isRetryable == null ? undefined : isRetryable(response, parsedError)
-      })
-    };
-  } catch (parseError) {
-    return {
-      responseHeaders,
-      value: new APICallError({
-        message: response.statusText,
-        url: url2,
-        requestBodyValues,
-        statusCode: response.status,
-        responseHeaders,
-        responseBody,
-        isRetryable: isRetryable == null ? undefined : isRetryable(response)
-      })
-    };
-  }
-};
-var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
-  const responseHeaders = extractResponseHeaders(response);
-  if (response.body == null) {
-    throw new EmptyResponseBodyError({});
-  }
-  return {
-    responseHeaders,
-    value: parseJsonEventStream({
-      stream: response.body,
-      schema: chunkSchema
-    })
-  };
-};
-var createJsonResponseHandler = (responseSchema) => async ({ response, url: url2, requestBodyValues }) => {
-  const responseBody = await response.text();
-  const parsedResult = await safeParseJSON({
-    text: responseBody,
-    schema: responseSchema
-  });
-  const responseHeaders = extractResponseHeaders(response);
-  if (!parsedResult.success) {
-    throw new APICallError({
-      message: "Invalid JSON response",
-      cause: parsedResult.error,
-      statusCode: response.status,
-      responseHeaders,
-      responseBody,
-      url: url2,
-      requestBodyValues
-    });
-  }
-  return {
-    responseHeaders,
-    value: parsedResult.value,
-    rawValue: parsedResult.rawValue
-  };
-};
 var getRelativePath = (pathA, pathB) => {
   let i = 0;
   for (;i < pathA.length && i < pathB.length; i++) {
@@ -44079,9 +43634,6 @@ function convertUint8ArrayToBase64(array2) {
   }
   return btoa2(latin1string);
 }
-function withoutTrailingSlash(url2) {
-  return url2 == null ? undefined : url2.replace(/\/$/, "");
-}
 function isAsyncIterable(obj) {
   return obj != null && typeof obj[Symbol.asyncIterator] === "function";
 }
@@ -44102,6 +43654,492 @@ async function* executeTool({
     yield { type: "final", output: await result };
   }
 }
+// ../../node_modules/@ai-sdk/gateway/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+function combineHeaders(...headers) {
+  return headers.reduce((combinedHeaders, currentHeaders) => ({
+    ...combinedHeaders,
+    ...currentHeaders != null ? currentHeaders : {}
+  }), {});
+}
+function extractResponseHeaders(response) {
+  return Object.fromEntries([...response.headers]);
+}
+var createIdGenerator2 = ({
+  prefix,
+  size = 16,
+  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator = "-"
+} = {}) => {
+  const generator = () => {
+    const alphabetLength = alphabet.length;
+    const chars = new Array(size);
+    for (let i = 0;i < size; i++) {
+      chars[i] = alphabet[Math.random() * alphabetLength | 0];
+    }
+    return chars.join("");
+  };
+  if (prefix == null) {
+    return generator;
+  }
+  if (alphabet.includes(separator)) {
+    throw new InvalidArgumentError({
+      argument: "separator",
+      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+    });
+  }
+  return () => `${prefix}${separator}${generator()}`;
+};
+var generateId2 = createIdGenerator2();
+function isAbortError2(error43) {
+  return (error43 instanceof Error || error43 instanceof DOMException) && (error43.name === "AbortError" || error43.name === "ResponseAborted" || error43.name === "TimeoutError");
+}
+var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+function handleFetchError({
+  error: error43,
+  url: url2,
+  requestBodyValues
+}) {
+  if (isAbortError2(error43)) {
+    return error43;
+  }
+  if (error43 instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error43.message.toLowerCase())) {
+    const cause = error43.cause;
+    if (cause != null) {
+      return new APICallError({
+        message: `Cannot connect to API: ${cause.message}`,
+        cause,
+        url: url2,
+        requestBodyValues,
+        isRetryable: true
+      });
+    }
+  }
+  return error43;
+}
+function removeUndefinedEntries(record2) {
+  return Object.fromEntries(Object.entries(record2).filter(([_key, value]) => value != null));
+}
+var getOriginalFetch = () => globalThis.fetch;
+var getFromApi = async ({
+  url: url2,
+  headers = {},
+  successfulResponseHandler,
+  failedResponseHandler,
+  abortSignal,
+  fetch: fetch2 = getOriginalFetch()
+}) => {
+  try {
+    const response = await fetch2(url2, {
+      method: "GET",
+      headers: removeUndefinedEntries(headers),
+      signal: abortSignal
+    });
+    const responseHeaders = extractResponseHeaders(response);
+    if (!response.ok) {
+      let errorInformation;
+      try {
+        errorInformation = await failedResponseHandler({
+          response,
+          url: url2,
+          requestBodyValues: {}
+        });
+      } catch (error43) {
+        if (isAbortError2(error43) || APICallError.isInstance(error43)) {
+          throw error43;
+        }
+        throw new APICallError({
+          message: "Failed to process error response",
+          cause: error43,
+          statusCode: response.status,
+          url: url2,
+          responseHeaders,
+          requestBodyValues: {}
+        });
+      }
+      throw errorInformation.value;
+    }
+    try {
+      return await successfulResponseHandler({
+        response,
+        url: url2,
+        requestBodyValues: {}
+      });
+    } catch (error43) {
+      if (error43 instanceof Error) {
+        if (isAbortError2(error43) || APICallError.isInstance(error43)) {
+          throw error43;
+        }
+      }
+      throw new APICallError({
+        message: "Failed to process successful response",
+        cause: error43,
+        statusCode: response.status,
+        url: url2,
+        responseHeaders,
+        requestBodyValues: {}
+      });
+    }
+  } catch (error43) {
+    throw handleFetchError({ error: error43, url: url2, requestBodyValues: {} });
+  }
+};
+function loadOptionalSetting({
+  settingValue,
+  environmentVariableName
+}) {
+  if (typeof settingValue === "string") {
+    return settingValue;
+  }
+  if (settingValue != null || typeof process === "undefined") {
+    return;
+  }
+  settingValue = process.env[environmentVariableName];
+  if (settingValue == null || typeof settingValue !== "string") {
+    return;
+  }
+  return settingValue;
+}
+var suspectProtoRx2 = /"__proto__"\s*:/;
+var suspectConstructorRx2 = /"constructor"\s*:/;
+function _parse3(text) {
+  const obj = JSON.parse(text);
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (suspectProtoRx2.test(text) === false && suspectConstructorRx2.test(text) === false) {
+    return obj;
+  }
+  return filter2(obj);
+}
+function filter2(obj) {
+  let next = [obj];
+  while (next.length) {
+    const nodes = next;
+    next = [];
+    for (const node of nodes) {
+      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      for (const key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          next.push(value);
+        }
+      }
+    }
+  }
+  return obj;
+}
+function secureJsonParse2(text) {
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  try {
+    return _parse3(text);
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit;
+  }
+}
+var validatorSymbol2 = Symbol.for("vercel.ai.validator");
+function validator2(validate) {
+  return { [validatorSymbol2]: true, validate };
+}
+function isValidator2(value) {
+  return typeof value === "object" && value !== null && validatorSymbol2 in value && value[validatorSymbol2] === true && "validate" in value;
+}
+function asValidator2(value) {
+  return isValidator2(value) ? value : standardSchemaValidator2(value);
+}
+function standardSchemaValidator2(standardSchema) {
+  return validator2(async (value) => {
+    const result = await standardSchema["~standard"].validate(value);
+    return result.issues == null ? { success: true, value: result.value } : {
+      success: false,
+      error: new TypeValidationError({
+        value,
+        cause: result.issues
+      })
+    };
+  });
+}
+async function validateTypes2({
+  value,
+  schema
+}) {
+  const result = await safeValidateTypes2({ value, schema });
+  if (!result.success) {
+    throw TypeValidationError.wrap({ value, cause: result.error });
+  }
+  return result.value;
+}
+async function safeValidateTypes2({
+  value,
+  schema
+}) {
+  const validator22 = asValidator2(schema);
+  try {
+    if (validator22.validate == null) {
+      return { success: true, value, rawValue: value };
+    }
+    const result = await validator22.validate(value);
+    if (result.success) {
+      return { success: true, value: result.value, rawValue: value };
+    }
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: result.error }),
+      rawValue: value
+    };
+  } catch (error43) {
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: error43 }),
+      rawValue: value
+    };
+  }
+}
+async function parseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = secureJsonParse2(text);
+    if (schema == null) {
+      return value;
+    }
+    return validateTypes2({ value, schema });
+  } catch (error43) {
+    if (JSONParseError.isInstance(error43) || TypeValidationError.isInstance(error43)) {
+      throw error43;
+    }
+    throw new JSONParseError({ text, cause: error43 });
+  }
+}
+async function safeParseJSON2({
+  text,
+  schema
+}) {
+  try {
+    const value = secureJsonParse2(text);
+    if (schema == null) {
+      return { success: true, value, rawValue: value };
+    }
+    return await safeValidateTypes2({ value, schema });
+  } catch (error43) {
+    return {
+      success: false,
+      error: JSONParseError.isInstance(error43) ? error43 : new JSONParseError({ text, cause: error43 }),
+      rawValue: undefined
+    };
+  }
+}
+function parseJsonEventStream({
+  stream,
+  schema
+}) {
+  return stream.pipeThrough(new TextDecoderStream).pipeThrough(new EventSourceParserStream).pipeThrough(new TransformStream({
+    async transform({ data }, controller) {
+      if (data === "[DONE]") {
+        return;
+      }
+      controller.enqueue(await safeParseJSON2({ text: data, schema }));
+    }
+  }));
+}
+var getOriginalFetch2 = () => globalThis.fetch;
+var postJsonToApi = async ({
+  url: url2,
+  headers,
+  body,
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch: fetch2
+}) => postToApi({
+  url: url2,
+  headers: {
+    "Content-Type": "application/json",
+    ...headers
+  },
+  body: {
+    content: JSON.stringify(body),
+    values: body
+  },
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch: fetch2
+});
+var postToApi = async ({
+  url: url2,
+  headers = {},
+  body,
+  successfulResponseHandler,
+  failedResponseHandler,
+  abortSignal,
+  fetch: fetch2 = getOriginalFetch2()
+}) => {
+  try {
+    const response = await fetch2(url2, {
+      method: "POST",
+      headers: removeUndefinedEntries(headers),
+      body: body.content,
+      signal: abortSignal
+    });
+    const responseHeaders = extractResponseHeaders(response);
+    if (!response.ok) {
+      let errorInformation;
+      try {
+        errorInformation = await failedResponseHandler({
+          response,
+          url: url2,
+          requestBodyValues: body.values
+        });
+      } catch (error43) {
+        if (isAbortError2(error43) || APICallError.isInstance(error43)) {
+          throw error43;
+        }
+        throw new APICallError({
+          message: "Failed to process error response",
+          cause: error43,
+          statusCode: response.status,
+          url: url2,
+          responseHeaders,
+          requestBodyValues: body.values
+        });
+      }
+      throw errorInformation.value;
+    }
+    try {
+      return await successfulResponseHandler({
+        response,
+        url: url2,
+        requestBodyValues: body.values
+      });
+    } catch (error43) {
+      if (error43 instanceof Error) {
+        if (isAbortError2(error43) || APICallError.isInstance(error43)) {
+          throw error43;
+        }
+      }
+      throw new APICallError({
+        message: "Failed to process successful response",
+        cause: error43,
+        statusCode: response.status,
+        url: url2,
+        responseHeaders,
+        requestBodyValues: body.values
+      });
+    }
+  } catch (error43) {
+    throw handleFetchError({ error: error43, url: url2, requestBodyValues: body.values });
+  }
+};
+async function resolve(value) {
+  if (typeof value === "function") {
+    value = value();
+  }
+  return Promise.resolve(value);
+}
+var createJsonErrorResponseHandler = ({
+  errorSchema,
+  errorToMessage,
+  isRetryable
+}) => async ({ response, url: url2, requestBodyValues }) => {
+  const responseBody = await response.text();
+  const responseHeaders = extractResponseHeaders(response);
+  if (responseBody.trim() === "") {
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: response.statusText,
+        url: url2,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? undefined : isRetryable(response)
+      })
+    };
+  }
+  try {
+    const parsedError = await parseJSON({
+      text: responseBody,
+      schema: errorSchema
+    });
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: errorToMessage(parsedError),
+        url: url2,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        data: parsedError,
+        isRetryable: isRetryable == null ? undefined : isRetryable(response, parsedError)
+      })
+    };
+  } catch (parseError) {
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: response.statusText,
+        url: url2,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? undefined : isRetryable(response)
+      })
+    };
+  }
+};
+var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
+  const responseHeaders = extractResponseHeaders(response);
+  if (response.body == null) {
+    throw new EmptyResponseBodyError({});
+  }
+  return {
+    responseHeaders,
+    value: parseJsonEventStream({
+      stream: response.body,
+      schema: chunkSchema
+    })
+  };
+};
+var createJsonResponseHandler = (responseSchema) => async ({ response, url: url2, requestBodyValues }) => {
+  const responseBody = await response.text();
+  const parsedResult = await safeParseJSON2({
+    text: responseBody,
+    schema: responseSchema
+  });
+  const responseHeaders = extractResponseHeaders(response);
+  if (!parsedResult.success) {
+    throw new APICallError({
+      message: "Invalid JSON response",
+      cause: parsedResult.error,
+      statusCode: response.status,
+      responseHeaders,
+      responseBody,
+      url: url2,
+      requestBodyValues
+    });
+  }
+  return {
+    responseHeaders,
+    value: parsedResult.value,
+    rawValue: parsedResult.rawValue
+  };
+};
+var ignoreOverride2 = Symbol("Let zodToJsonSchema decide on which parser to use");
+var ALPHA_NUMERIC2 = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+var schemaSymbol2 = Symbol.for("vercel.ai.schema");
+function withoutTrailingSlash(url2) {
+  return url2 == null ? undefined : url2.replace(/\/$/, "");
+}
 
 // ../../node_modules/@ai-sdk/gateway/dist/index.mjs
 var marker15 = "vercel.ai.gateway.error";
@@ -51173,64 +51211,6 @@ var createNewProject_default = {
   agent: "architect"
 };
 
-// ../core/src/AiTool/generateProjectConfig.ts
-var prompt2 = `
-Role: Analyzer agent
-Goal: Produce a valid polkacodes YAML configuration for the project.
-
-Workflow
-1. Scan project files with tool_read_file and identify:
-   - Package/build tool (npm, bun, pnpm, etc.)
-   - Test framework and patterns (snapshot tests, coverage, etc.)
-   - Formatter / linter and their rules
-   - Folder structure and naming conventions
-   - CI / development workflows
-
-2. Build a YAML config with three root keys:
-
-\`\`\`yaml
-scripts:          # derive from package.json and CI
-  format:        # code formatter
-    command: "<formatter cmd>"
-    description: "Format code"
-  check:         # linter / type checker
-    command: "<linter cmd>"
-    description: "Static checks"
-  test:          # test runner
-    command: "<test cmd>"
-    description: "Run tests"
-  # add any other meaningful project scripts
-
-rules:            # bullet list of key conventions/tools
-
-excludeFiles:     # only files likely to hold secrets
-  - ".env"
-  - ".env.*"
-  - ".npmrc"
-  # do NOT list build artifacts, lockfiles, or paths already in .gitignore
-\`\`\`
-
-3. Return the YAML exactly once, wrapped like:
-
-<tool_attempt_completion>
-<tool_parameter_result>
-# YAML (2-space indents, double-quoted commands)
-</tool_parameter_result>
-</tool_attempt_completion>
-`;
-var generateProjectConfig_default = {
-  name: "generateProjectConfig",
-  description: "Analyzes project files to generate polkacodes config sections",
-  prompt: prompt2,
-  formatInput: () => {
-    return "";
-  },
-  parseOutput: (output) => {
-    return output;
-  },
-  agent: "analyzer"
-};
-
 // ../core/src/AiTool/index.ts
 var executeMultiAgentTool = async (definition, agent, params) => {
   const exitReason = await agent.startTask({
@@ -51248,79 +51228,9 @@ var makeMultiAgentTool = (definition) => {
     return executeMultiAgentTool(definition, agent, params);
   };
 };
-var generateProjectConfig = makeMultiAgentTool(generateProjectConfig_default);
 var createNewProject = makeMultiAgentTool(createNewProject_default);
-// ../core/src/workflow/utils.ts
-var import_lodash2 = __toESM(require_lodash(), 1);
-// ../core/src/workflow/builder.ts
-class StepsBuilder {
-  #steps = [];
-  build() {
-    if (this.#steps.length === 0) {
-      throw new Error("A workflow must have at least one step.");
-    }
-    const rootStep = this.#steps.length > 1 ? {
-      id: "root",
-      type: "sequential",
-      steps: this.#steps
-    } : this.#steps[0];
-    return rootStep;
-  }
-  step(step) {
-    this.#steps.push(step);
-    return this;
-  }
-  parallel(id, step) {
-    return this.step({
-      id,
-      type: "parallel",
-      step
-    });
-  }
-  loop(id, config2) {
-    return this.step({
-      ...config2,
-      id,
-      type: "loop"
-    });
-  }
-  custom(idOrSpec, run) {
-    if (typeof idOrSpec === "string") {
-      if (!run) {
-        throw new Error('Custom step "run" function must be provided.');
-      }
-      return this.step({
-        id: idOrSpec,
-        type: "custom",
-        run
-      });
-    }
-    return this.step(idOrSpec);
-  }
-  workflow(id, config2) {
-    return this.step({
-      ...config2,
-      id,
-      type: "workflow"
-    });
-  }
-  agent(id, spec2) {
-    return this.step({
-      ...spec2,
-      id,
-      type: "agent"
-    });
-  }
-  branch(id, config2) {
-    return this.step({
-      ...config2,
-      id,
-      type: "branch"
-    });
-  }
-}
 // src/config.ts
-var import_lodash3 = __toESM(require_lodash(), 1);
+var import_lodash2 = __toESM(require_lodash(), 1);
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -53965,9 +53875,9 @@ class ZodUnion3 extends ZodType3 {
     return this._def.options;
   }
 }
-ZodUnion3.create = (types2, params) => {
+ZodUnion3.create = (types, params) => {
   return new ZodUnion3({
-    options: types2,
+    options: types,
     typeName: ZodFirstPartyTypeKind3.ZodUnion,
     ...processCreateParams2(params)
   });
@@ -55231,7 +55141,7 @@ function mergeConfigs(configs) {
     return {};
   }
   const mergedConfig = configs.reduce((acc, config3) => {
-    const merged = import_lodash3.merge({}, acc, config3);
+    const merged = import_lodash2.merge({}, acc, config3);
     let accRules = acc.rules ?? [];
     if (typeof accRules === "string") {
       accRules = [accRules];
@@ -56168,15 +56078,29 @@ var {
 } = signalExitWrap(processOk(process3) ? new SignalExit(process3) : new SignalExitFallback);
 
 // ../../node_modules/@inquirer/core/dist/esm/lib/screen-manager.js
-var import_ansi_escapes = __toESM(require_ansi_escapes(), 1);
 import { stripVTControlCharacters } from "node:util";
+
+// ../../node_modules/@inquirer/ansi/dist/esm/index.js
+var ESC = "\x1B[";
+var cursorLeft = ESC + "G";
+var cursorHide = ESC + "?25l";
+var cursorShow = ESC + "?25h";
+var cursorUp = (rows = 1) => rows > 0 ? `${ESC}${rows}A` : "";
+var cursorDown = (rows = 1) => rows > 0 ? `${ESC}${rows}B` : "";
+var cursorTo = (x, y) => {
+  if (typeof y === "number" && !Number.isNaN(y)) {
+    return `${ESC}${y + 1};${x + 1}H`;
+  }
+  return `${ESC}${x + 1}G`;
+};
+var eraseLine = ESC + "2K";
+var eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
+
+// ../../node_modules/@inquirer/core/dist/esm/lib/screen-manager.js
 var height = (content) => content.split(`
 `).length;
 var lastLine = (content) => content.split(`
 `).pop() ?? "";
-function cursorDown(n) {
-  return n > 0 ? import_ansi_escapes.default.cursorDown(n) : "";
-}
 
 class ScreenManager {
   height = 0;
@@ -56195,11 +56119,11 @@ class ScreenManager {
   render(content, bottomContent = "") {
     const promptLine = lastLine(content);
     const rawPromptLine = stripVTControlCharacters(promptLine);
-    let prompt3 = rawPromptLine;
+    let prompt2 = rawPromptLine;
     if (this.rl.line.length > 0) {
-      prompt3 = prompt3.slice(0, -this.rl.line.length);
+      prompt2 = prompt2.slice(0, -this.rl.line.length);
     }
-    this.rl.setPrompt(prompt3);
+    this.rl.setPrompt(prompt2);
     this.cursorPos = this.rl.getCursorPos();
     const width = readlineWidth();
     content = breakLines(content, width);
@@ -56213,25 +56137,25 @@ class ScreenManager {
     const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
     const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
     if (bottomContentHeight > 0)
-      output += import_ansi_escapes.default.cursorUp(bottomContentHeight);
-    output += import_ansi_escapes.default.cursorTo(this.cursorPos.cols);
-    this.write(cursorDown(this.extraLinesUnderPrompt) + import_ansi_escapes.default.eraseLines(this.height) + output);
+      output += cursorUp(bottomContentHeight);
+    output += cursorTo(this.cursorPos.cols);
+    this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
     this.extraLinesUnderPrompt = bottomContentHeight;
     this.height = height(output);
   }
   checkCursorPos() {
     const cursorPos = this.rl.getCursorPos();
     if (cursorPos.cols !== this.cursorPos.cols) {
-      this.write(import_ansi_escapes.default.cursorTo(cursorPos.cols));
+      this.write(cursorTo(cursorPos.cols));
       this.cursorPos = cursorPos;
     }
   }
   done({ clearContent }) {
     this.rl.setPrompt("");
     let output = cursorDown(this.extraLinesUnderPrompt);
-    output += clearContent ? import_ansi_escapes.default.eraseLines(this.height) : `
+    output += clearContent ? eraseLines(this.height) : `
 `;
-    output += import_ansi_escapes.default.cursorShow;
+    output += cursorShow;
     this.write(output);
     this.rl.close();
   }
@@ -56269,7 +56193,7 @@ function getCallSites() {
 }
 function createPrompt(view) {
   const callSites = getCallSites();
-  const prompt3 = (config3, context = {}) => {
+  const prompt2 = (config3, context = {}) => {
     const { input = process.stdin, signal } = context;
     const cleanups = new Set;
     const output = new import_mute_stream.default;
@@ -56334,7 +56258,7 @@ function createPrompt(view) {
       }).then(() => promise2), { cancel });
     });
   };
-  return prompt3;
+  return prompt2;
 }
 // ../../node_modules/@inquirer/core/dist/esm/lib/Separator.js
 var import_yoctocolors_cjs2 = __toESM(require_yoctocolors_cjs(), 1);
@@ -56423,7 +56347,6 @@ var esm_default2 = createPrompt((config3, done) => {
 });
 // ../../node_modules/@inquirer/select/dist/esm/index.js
 var import_yoctocolors_cjs3 = __toESM(require_yoctocolors_cjs(), 1);
-var import_ansi_escapes2 = __toESM(require_ansi_escapes(), 1);
 var selectTheme = {
   icon: { cursor: esm_default.pointer },
   style: {
@@ -56574,7 +56497,7 @@ ${theme.style.help(`(${config3.instructions?.pager ?? "Use arrow keys to reveal
   const choiceDescription = selectedChoice.description ? `
 ${theme.style.description(selectedChoice.description)}` : ``;
   return `${[prefix, message, helpTipTop].filter(Boolean).join(" ")}
-${page}${helpTipBottom}${choiceDescription}${import_ansi_escapes2.default.cursorHide}`;
+${page}${helpTipBottom}${choiceDescription}${cursorHide}`;
 });
 // src/provider.ts
 var import_ignore2 = __toESM(require_ignore(), 1);
@@ -56616,7 +56539,7 @@ function lookup(path) {
   }
   return $types[extension2] || false;
 }
-function populateMaps(extensions, types2) {
+function populateMaps(extensions, types) {
   Object.keys(db).forEach(function forEachMimeType(type) {
     var mime = db[type];
     var exts = mime.extensions;
@@ -56626,10 +56549,10 @@ function populateMaps(extensions, types2) {
     extensions[type] = exts;
     for (var i = 0;i < exts.length; i++) {
       var extension2 = exts[i];
-      types2[extension2] = _preferredType(extension2, types2[extension2], type);
-      const legacyType = _preferredTypeLegacy(extension2, types2[extension2], type);
-      if (legacyType !== types2[extension2]) {
-        $_extensionConflicts.push([extension2, legacyType, types2[extension2]]);
+      types[extension2] = _preferredType(extension2, types[extension2], type);
+      const legacyType = _preferredTypeLegacy(extension2, types[extension2], type);
+      if (legacyType !== types[extension2]) {
+        $_extensionConflicts.push([extension2, legacyType, types[extension2]]);
       }
     }
   });
@@ -56874,10 +56797,10 @@ var getProvider = (options = {}) => {
         mediaType
       };
     },
-    executeCommand: (command2, _needApprove) => {
+    executeCommand: (command, _needApprove) => {
       return new Promise((resolve4, reject) => {
-        options.command?.onStarted(command2);
-        const child = spawn2(command2, [], {
+        options.command?.onStarted(command);
+        const child = spawn2(command, [], {
           shell: true,
           stdio: "pipe"
         });
@@ -57340,17 +57263,17 @@ Object.setPrototypeOf(createChalk.prototype, Function.prototype);
 for (const [styleName, style] of Object.entries(ansi_styles_default)) {
   styles2[styleName] = {
     get() {
-      const builder2 = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder2 });
-      return builder2;
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
     }
   };
 }
 styles2.visible = {
   get() {
-    const builder2 = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder2 });
-    return builder2;
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
   }
 };
 var getModelAnsi = (model, level, type, ...arguments_) => {
@@ -57421,12 +57344,12 @@ var createStyler = (open, close, parent) => {
   };
 };
 var createBuilder = (self2, _styler, _isEmpty) => {
-  const builder2 = (...arguments_) => applyStyle(builder2, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder2, proto);
-  builder2[GENERATOR] = self2;
-  builder2[STYLER] = _styler;
-  builder2[IS_EMPTY] = _isEmpty;
-  return builder2;
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self2;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
 };
 var applyStyle = (self2, string4) => {
   if (self2.level <= 0 || !string4) {
@@ -57531,25 +57454,21 @@ ${event.systemPrompt}`);
         break;
       case "Usage" /* Usage */:
         break;
-      case "Text" /* Text */:
-        if (customConsole !== console) {
-          break;
-        }
+      case "Text" /* Text */: {
         if (hadReasoning) {
-          process.stdout.write(`
+          customConsole.write(`
 
 `);
           hadReasoning = false;
         }
-        process.stdout.write(event.newText);
+        customConsole.write(event.newText);
         break;
-      case "Reasoning" /* Reasoning */:
-        if (customConsole !== console) {
-          break;
-        }
-        process.stdout.write(source_default.dim(event.newText));
+      }
+      case "Reasoning" /* Reasoning */: {
+        customConsole.write(source_default.dim(event.newText));
         hadReasoning = true;
         break;
+      }
       case "ToolUse" /* ToolUse */: {
         customConsole.log(source_default.yellow(`