@getpochi/cli 0.5.59 → 0.5.60

package/dist/cli.js

@@ -339425,6 +339425,24 @@ var UnsupportedFunctionalityError = class extends AISDKError {
   }
 };
 _a14 = symbol14;
+function isJSONValue(value2) {
+  if (value2 === null || typeof value2 === "string" || typeof value2 === "number" || typeof value2 === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value2)) {
+    return value2.every(isJSONValue);
+  }
+  if (typeof value2 === "object") {
+    return Object.entries(value2).every(([key, val]) => typeof key === "string" && isJSONValue(val));
+  }
+  return false;
+}
+function isJSONArray(value2) {
+  return Array.isArray(value2) && value2.every(isJSONValue);
+}
+function isJSONObject(value2) {
+  return value2 != null && typeof value2 === "object" && Object.entries(value2).every(([key, val]) => typeof key === "string" && isJSONValue(val));
+}
 
 // ../../node_modules/eventsource-parser/dist/index.js
 class ParseError extends Error {
@@ -347433,6 +347451,13 @@ function prepareRetries({
     })
   };
 }
+function extractTextContent(content) {
+  const parts = content.filter((content2) => content2.type === "text");
+  if (parts.length === 0) {
+    return;
+  }
+  return parts.map((content2) => content2.text).join("");
+}
 var DefaultGeneratedFile = class {
   constructor({
     data,
@@ -350721,7 +350746,651 @@ function convertToModelMessages(messages, options) {
   }
   return modelMessages;
 }
+function extractReasoningContent(content) {
+  const parts = content.filter((content2) => content2.type === "reasoning");
+  return parts.length === 0 ? undefined : parts.map((content2) => content2.text).join(`
+`);
+}
+var noSchemaOutputStrategy = {
+  type: "no-schema",
+  jsonSchema: undefined,
+  async validatePartialResult({ value: value2, textDelta }) {
+    return { success: true, value: { partial: value2, textDelta } };
+  },
+  async validateFinalResult(value2, context) {
+    return value2 === undefined ? {
+      success: false,
+      error: new NoObjectGeneratedError({
+        message: "No object generated: response did not match schema.",
+        text: context.text,
+        response: context.response,
+        usage: context.usage,
+        finishReason: context.finishReason
+      })
+    } : { success: true, value: value2 };
+  },
+  createElementStream() {
+    throw new UnsupportedFunctionalityError({
+      functionality: "element streams in no-schema mode"
+    });
+  }
+};
+var objectOutputStrategy = (schema) => ({
+  type: "object",
+  jsonSchema: schema.jsonSchema,
+  async validatePartialResult({ value: value2, textDelta }) {
+    return {
+      success: true,
+      value: {
+        partial: value2,
+        textDelta
+      }
+    };
+  },
+  async validateFinalResult(value2) {
+    return safeValidateTypes({ value: value2, schema });
+  },
+  createElementStream() {
+    throw new UnsupportedFunctionalityError({
+      functionality: "element streams in object mode"
+    });
+  }
+});
+var arrayOutputStrategy = (schema) => {
+  const { $schema, ...itemSchema } = schema.jsonSchema;
+  return {
+    type: "enum",
+    jsonSchema: {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      type: "object",
+      properties: {
+        elements: { type: "array", items: itemSchema }
+      },
+      required: ["elements"],
+      additionalProperties: false
+    },
+    async validatePartialResult({
+      value: value2,
+      latestObject,
+      isFirstDelta,
+      isFinalDelta
+    }) {
+      var _a172;
+      if (!isJSONObject(value2) || !isJSONArray(value2.elements)) {
+        return {
+          success: false,
+          error: new TypeValidationError({
+            value: value2,
+            cause: "value must be an object that contains an array of elements"
+          })
+        };
+      }
+      const inputArray = value2.elements;
+      const resultArray = [];
+      for (let i6 = 0;i6 < inputArray.length; i6++) {
+        const element = inputArray[i6];
+        const result2 = await safeValidateTypes({ value: element, schema });
+        if (i6 === inputArray.length - 1 && !isFinalDelta) {
+          continue;
+        }
+        if (!result2.success) {
+          return result2;
+        }
+        resultArray.push(result2.value);
+      }
+      const publishedElementCount = (_a172 = latestObject == null ? undefined : latestObject.length) != null ? _a172 : 0;
+      let textDelta = "";
+      if (isFirstDelta) {
+        textDelta += "[";
+      }
+      if (publishedElementCount > 0) {
+        textDelta += ",";
+      }
+      textDelta += resultArray.slice(publishedElementCount).map((element) => JSON.stringify(element)).join(",");
+      if (isFinalDelta) {
+        textDelta += "]";
+      }
+      return {
+        success: true,
+        value: {
+          partial: resultArray,
+          textDelta
+        }
+      };
+    },
+    async validateFinalResult(value2) {
+      if (!isJSONObject(value2) || !isJSONArray(value2.elements)) {
+        return {
+          success: false,
+          error: new TypeValidationError({
+            value: value2,
+            cause: "value must be an object that contains an array of elements"
+          })
+        };
+      }
+      const inputArray = value2.elements;
+      for (const element of inputArray) {
+        const result2 = await safeValidateTypes({ value: element, schema });
+        if (!result2.success) {
+          return result2;
+        }
+      }
+      return { success: true, value: inputArray };
+    },
+    createElementStream(originalStream) {
+      let publishedElements = 0;
+      return createAsyncIterableStream(originalStream.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+          switch (chunk.type) {
+            case "object": {
+              const array2 = chunk.object;
+              for (;publishedElements < array2.length; publishedElements++) {
+                controller.enqueue(array2[publishedElements]);
+              }
+              break;
+            }
+            case "text-delta":
+            case "finish":
+            case "error":
+              break;
+            default: {
+              const _exhaustiveCheck = chunk;
+              throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
+            }
+          }
+        }
+      })));
+    }
+  };
+};
+var enumOutputStrategy = (enumValues) => {
+  return {
+    type: "enum",
+    jsonSchema: {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      type: "object",
+      properties: {
+        result: { type: "string", enum: enumValues }
+      },
+      required: ["result"],
+      additionalProperties: false
+    },
+    async validateFinalResult(value2) {
+      if (!isJSONObject(value2) || typeof value2.result !== "string") {
+        return {
+          success: false,
+          error: new TypeValidationError({
+            value: value2,
+            cause: 'value must be an object that contains a string in the "result" property.'
+          })
+        };
+      }
+      const result2 = value2.result;
+      return enumValues.includes(result2) ? { success: true, value: result2 } : {
+        success: false,
+        error: new TypeValidationError({
+          value: value2,
+          cause: "value must be a string in the enum"
+        })
+      };
+    },
+    async validatePartialResult({ value: value2, textDelta }) {
+      if (!isJSONObject(value2) || typeof value2.result !== "string") {
+        return {
+          success: false,
+          error: new TypeValidationError({
+            value: value2,
+            cause: 'value must be an object that contains a string in the "result" property.'
+          })
+        };
+      }
+      const result2 = value2.result;
+      const possibleEnumValues = enumValues.filter((enumValue) => enumValue.startsWith(result2));
+      if (value2.result.length === 0 || possibleEnumValues.length === 0) {
+        return {
+          success: false,
+          error: new TypeValidationError({
+            value: value2,
+            cause: "value must be a string in the enum"
+          })
+        };
+      }
+      return {
+        success: true,
+        value: {
+          partial: possibleEnumValues.length > 1 ? result2 : possibleEnumValues[0],
+          textDelta
+        }
+      };
+    },
+    createElementStream() {
+      throw new UnsupportedFunctionalityError({
+        functionality: "element streams in enum mode"
+      });
+    }
+  };
+};
+function getOutputStrategy({
+  output,
+  schema,
+  enumValues
+}) {
+  switch (output) {
+    case "object":
+      return objectOutputStrategy(asSchema(schema));
+    case "array":
+      return arrayOutputStrategy(asSchema(schema));
+    case "enum":
+      return enumOutputStrategy(enumValues);
+    case "no-schema":
+      return noSchemaOutputStrategy;
+    default: {
+      const _exhaustiveCheck = output;
+      throw new Error(`Unsupported output: ${_exhaustiveCheck}`);
+    }
+  }
+}
+async function parseAndValidateObjectResult(result2, outputStrategy, context) {
+  const parseResult = await safeParseJSON({ text: result2 });
+  if (!parseResult.success) {
+    throw new NoObjectGeneratedError({
+      message: "No object generated: could not parse the response.",
+      cause: parseResult.error,
+      text: result2,
+      response: context.response,
+      usage: context.usage,
+      finishReason: context.finishReason
+    });
+  }
+  const validationResult = await outputStrategy.validateFinalResult(parseResult.value, {
+    text: result2,
+    response: context.response,
+    usage: context.usage
+  });
+  if (!validationResult.success) {
+    throw new NoObjectGeneratedError({
+      message: "No object generated: response did not match schema.",
+      cause: validationResult.error,
+      text: result2,
+      response: context.response,
+      usage: context.usage,
+      finishReason: context.finishReason
+    });
+  }
+  return validationResult.value;
+}
+async function parseAndValidateObjectResultWithRepair(result2, outputStrategy, repairText, context) {
+  try {
+    return await parseAndValidateObjectResult(result2, outputStrategy, context);
+  } catch (error40) {
+    if (repairText != null && NoObjectGeneratedError.isInstance(error40) && (JSONParseError.isInstance(error40.cause) || TypeValidationError.isInstance(error40.cause))) {
+      const repairedText = await repairText({
+        text: result2,
+        error: error40.cause
+      });
+      if (repairedText === null) {
+        throw error40;
+      }
+      return await parseAndValidateObjectResult(repairedText, outputStrategy, context);
+    }
+    throw error40;
+  }
+}
+function validateObjectGenerationInput({
+  output,
+  schema,
+  schemaName,
+  schemaDescription,
+  enumValues
+}) {
+  if (output != null && output !== "object" && output !== "array" && output !== "enum" && output !== "no-schema") {
+    throw new InvalidArgumentError2({
+      parameter: "output",
+      value: output,
+      message: "Invalid output type."
+    });
+  }
+  if (output === "no-schema") {
+    if (schema != null) {
+      throw new InvalidArgumentError2({
+        parameter: "schema",
+        value: schema,
+        message: "Schema is not supported for no-schema output."
+      });
+    }
+    if (schemaDescription != null) {
+      throw new InvalidArgumentError2({
+        parameter: "schemaDescription",
+        value: schemaDescription,
+        message: "Schema description is not supported for no-schema output."
+      });
+    }
+    if (schemaName != null) {
+      throw new InvalidArgumentError2({
+        parameter: "schemaName",
+        value: schemaName,
+        message: "Schema name is not supported for no-schema output."
+      });
+    }
+    if (enumValues != null) {
+      throw new InvalidArgumentError2({
+        parameter: "enumValues",
+        value: enumValues,
+        message: "Enum values are not supported for no-schema output."
+      });
+    }
+  }
+  if (output === "object") {
+    if (schema == null) {
+      throw new InvalidArgumentError2({
+        parameter: "schema",
+        value: schema,
+        message: "Schema is required for object output."
+      });
+    }
+    if (enumValues != null) {
+      throw new InvalidArgumentError2({
+        parameter: "enumValues",
+        value: enumValues,
+        message: "Enum values are not supported for object output."
+      });
+    }
+  }
+  if (output === "array") {
+    if (schema == null) {
+      throw new InvalidArgumentError2({
+        parameter: "schema",
+        value: schema,
+        message: "Element schema is required for array output."
+      });
+    }
+    if (enumValues != null) {
+      throw new InvalidArgumentError2({
+        parameter: "enumValues",
+        value: enumValues,
+        message: "Enum values are not supported for array output."
+      });
+    }
+  }
+  if (output === "enum") {
+    if (schema != null) {
+      throw new InvalidArgumentError2({
+        parameter: "schema",
+        value: schema,
+        message: "Schema is not supported for enum output."
+      });
+    }
+    if (schemaDescription != null) {
+      throw new InvalidArgumentError2({
+        parameter: "schemaDescription",
+        value: schemaDescription,
+        message: "Schema description is not supported for enum output."
+      });
+    }
+    if (schemaName != null) {
+      throw new InvalidArgumentError2({
+        parameter: "schemaName",
+        value: schemaName,
+        message: "Schema name is not supported for enum output."
+      });
+    }
+    if (enumValues == null) {
+      throw new InvalidArgumentError2({
+        parameter: "enumValues",
+        value: enumValues,
+        message: "Enum values are required for enum output."
+      });
+    }
+    for (const value2 of enumValues) {
+      if (typeof value2 !== "string") {
+        throw new InvalidArgumentError2({
+          parameter: "enumValues",
+          value: value2,
+          message: "Enum values must be strings."
+        });
+      }
+    }
+  }
+}
 var originalGenerateId3 = createIdGenerator({ prefix: "aiobj", size: 24 });
+async function generateObject(options) {
+  const {
+    model: modelArg,
+    output = "object",
+    system,
+    prompt,
+    messages,
+    maxRetries: maxRetriesArg,
+    abortSignal,
+    headers,
+    experimental_repairText: repairText,
+    experimental_telemetry: telemetry,
+    experimental_download: download2,
+    providerOptions,
+    _internal: {
+      generateId: generateId3 = originalGenerateId3,
+      currentDate = () => /* @__PURE__ */ new Date
+    } = {},
+    ...settings
+  } = options;
+  const model = resolveLanguageModel(modelArg);
+  const enumValues = "enum" in options ? options.enum : undefined;
+  const {
+    schema: inputSchema,
+    schemaDescription,
+    schemaName
+  } = "schema" in options ? options : {};
+  validateObjectGenerationInput({
+    output,
+    schema: inputSchema,
+    schemaName,
+    schemaDescription,
+    enumValues
+  });
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
+  const outputStrategy = getOutputStrategy({
+    output,
+    schema: inputSchema,
+    enumValues
+  });
+  const callSettings = prepareCallSettings(settings);
+  const headersWithUserAgent = withUserAgentSuffix(headers != null ? headers : {}, `ai/${VERSION3}`);
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    model,
+    telemetry,
+    headers: headersWithUserAgent,
+    settings: { ...callSettings, maxRetries }
+  });
+  const tracer = getTracer(telemetry);
+  try {
+    return await recordSpan({
+      name: "ai.generateObject",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({
+            operationId: "ai.generateObject",
+            telemetry
+          }),
+          ...baseTelemetryAttributes,
+          "ai.prompt": {
+            input: () => JSON.stringify({ system, prompt, messages })
+          },
+          "ai.schema": outputStrategy.jsonSchema != null ? { input: () => JSON.stringify(outputStrategy.jsonSchema) } : undefined,
+          "ai.schema.name": schemaName,
+          "ai.schema.description": schemaDescription,
+          "ai.settings.output": outputStrategy.type
+        }
+      }),
+      tracer,
+      fn: async (span) => {
+        var _a172;
+        let result2;
+        let finishReason;
+        let usage;
+        let warnings;
+        let response;
+        let request;
+        let resultProviderMetadata;
+        let reasoning;
+        const standardizedPrompt = await standardizePrompt({
+          system,
+          prompt,
+          messages
+        });
+        const promptMessages = await convertToLanguageModelPrompt({
+          prompt: standardizedPrompt,
+          supportedUrls: await model.supportedUrls,
+          download: download2
+        });
+        const generateResult = await retry(() => recordSpan({
+          name: "ai.generateObject.doGenerate",
+          attributes: selectTelemetryAttributes({
+            telemetry,
+            attributes: {
+              ...assembleOperationName({
+                operationId: "ai.generateObject.doGenerate",
+                telemetry
+              }),
+              ...baseTelemetryAttributes,
+              "ai.prompt.messages": {
+                input: () => stringifyForTelemetry(promptMessages)
+              },
+              "gen_ai.system": model.provider,
+              "gen_ai.request.model": model.modelId,
+              "gen_ai.request.frequency_penalty": callSettings.frequencyPenalty,
+              "gen_ai.request.max_tokens": callSettings.maxOutputTokens,
+              "gen_ai.request.presence_penalty": callSettings.presencePenalty,
+              "gen_ai.request.temperature": callSettings.temperature,
+              "gen_ai.request.top_k": callSettings.topK,
+              "gen_ai.request.top_p": callSettings.topP
+            }
+          }),
+          tracer,
+          fn: async (span2) => {
+            var _a18, _b8, _c, _d, _e, _f, _g, _h;
+            const result22 = await model.doGenerate({
+              responseFormat: {
+                type: "json",
+                schema: outputStrategy.jsonSchema,
+                name: schemaName,
+                description: schemaDescription
+              },
+              ...prepareCallSettings(settings),
+              prompt: promptMessages,
+              providerOptions,
+              abortSignal,
+              headers: headersWithUserAgent
+            });
+            const responseData = {
+              id: (_b8 = (_a18 = result22.response) == null ? undefined : _a18.id) != null ? _b8 : generateId3(),
+              timestamp: (_d = (_c = result22.response) == null ? undefined : _c.timestamp) != null ? _d : currentDate(),
+              modelId: (_f = (_e = result22.response) == null ? undefined : _e.modelId) != null ? _f : model.modelId,
+              headers: (_g = result22.response) == null ? undefined : _g.headers,
+              body: (_h = result22.response) == null ? undefined : _h.body
+            };
+            const text2 = extractTextContent(result22.content);
+            const reasoning2 = extractReasoningContent(result22.content);
+            if (text2 === undefined) {
+              throw new NoObjectGeneratedError({
+                message: "No object generated: the model did not return a response.",
+                response: responseData,
+                usage: result22.usage,
+                finishReason: result22.finishReason
+              });
+            }
+            span2.setAttributes(selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                "ai.response.finishReason": result22.finishReason,
+                "ai.response.object": { output: () => text2 },
+                "ai.response.id": responseData.id,
+                "ai.response.model": responseData.modelId,
+                "ai.response.timestamp": responseData.timestamp.toISOString(),
+                "ai.response.providerMetadata": JSON.stringify(result22.providerMetadata),
+                "ai.usage.promptTokens": result22.usage.inputTokens,
+                "ai.usage.completionTokens": result22.usage.outputTokens,
+                "gen_ai.response.finish_reasons": [result22.finishReason],
+                "gen_ai.response.id": responseData.id,
+                "gen_ai.response.model": responseData.modelId,
+                "gen_ai.usage.input_tokens": result22.usage.inputTokens,
+                "gen_ai.usage.output_tokens": result22.usage.outputTokens
+              }
+            }));
+            return {
+              ...result22,
+              objectText: text2,
+              reasoning: reasoning2,
+              responseData
+            };
+          }
+        }));
+        result2 = generateResult.objectText;
+        finishReason = generateResult.finishReason;
+        usage = generateResult.usage;
+        warnings = generateResult.warnings;
+        resultProviderMetadata = generateResult.providerMetadata;
+        request = (_a172 = generateResult.request) != null ? _a172 : {};
+        response = generateResult.responseData;
+        reasoning = generateResult.reasoning;
+        logWarnings(warnings);
+        const object2 = await parseAndValidateObjectResultWithRepair(result2, outputStrategy, repairText, {
+          response,
+          usage,
+          finishReason
+        });
+        span.setAttributes(selectTelemetryAttributes({
+          telemetry,
+          attributes: {
+            "ai.response.finishReason": finishReason,
+            "ai.response.object": {
+              output: () => JSON.stringify(object2)
+            },
+            "ai.response.providerMetadata": JSON.stringify(resultProviderMetadata),
+            "ai.usage.promptTokens": usage.inputTokens,
+            "ai.usage.completionTokens": usage.outputTokens
+          }
+        }));
+        return new DefaultGenerateObjectResult({
+          object: object2,
+          reasoning,
+          finishReason,
+          usage,
+          warnings,
+          request,
+          response,
+          providerMetadata: resultProviderMetadata
+        });
+      }
+    });
+  } catch (error40) {
+    throw wrapGatewayError(error40);
+  }
+}
+var DefaultGenerateObjectResult = class {
+  constructor(options) {
+    this.object = options.object;
+    this.finishReason = options.finishReason;
+    this.usage = options.usage;
+    this.warnings = options.warnings;
+    this.providerMetadata = options.providerMetadata;
+    this.response = options.response;
+    this.request = options.request;
+    this.reasoning = options.reasoning;
+  }
+  toJsonResponse(init) {
+    var _a172;
+    return new Response(JSON.stringify(this.object), {
+      status: (_a172 = init == null ? undefined : init.status) != null ? _a172 : 200,
+      headers: prepareHeaders(init == null ? undefined : init.headers, {
+        "content-type": "application/json; charset=utf-8"
+      })
+    });
+  }
+};
 var SerialJobExecutor = class {
   constructor() {
     this.queue = [];
@@ -352096,15 +352765,16 @@ Use this tool in the following scenarios:
 var askFollowupQuestion = tool(toolDef2);
 
 // ../tools/src/attempt-completion.ts
+var attemptCompletionSchema = exports_external2.object({
+  result: exports_external2.string().describe("The result of the task. Formulate this result in a way that is final and does not require further input from the user."),
+  command: exports_external2.string().optional().describe("A CLI command to execute to show a live demo of the result to the user.")
+});
 var toolDef3 = {
   description: `After each tool use. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user.
 
 Never use this tool with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
 `.trim(),
-  inputSchema: exports_external2.object({
-    result: exports_external2.string().describe("The result of the task. Formulate this result in a way that is final and does not require further input from the user."),
-    command: exports_external2.string().optional().describe("A CLI command to execute to show a live demo of the result to the user.")
-  }),
+  inputSchema: attemptCompletionSchema,
   outputSchema: exports_external2.object({
     success: exports_external2.boolean().describe("Indicates whether the completion was successful.")
   })
@@ -367770,7 +368440,7 @@ var {
 // package.json
 var package_default = {
   name: "@getpochi/cli",
-  version: "0.5.59",
+  version: "0.5.60",
   type: "module",
   bin: {
     pochi: "src/cli.ts"
@@ -367814,7 +368484,8 @@ var package_default = {
     omelette: "^0.4.17",
     ora: "^8.2.0",
     remeda: "catalog:",
-    semver: "^7.6.3"
+    semver: "^7.6.3",
+    zod: "catalog:"
   }
 };
 
@@ -410199,6 +410870,77 @@ function createStopWordStream(stop3) {
     }
   });
 }
+// ../livekit/src/chat/middlewares/output-schema-middleware.ts
+function createOutputSchemaMiddleware(outputSchema2) {
+  return {
+    middlewareVersion: "v2",
+    wrapStream: async ({ doStream, model: model2 }) => {
+      const { stream: stream12, ...rest } = await doStream();
+      let toolCallId = "";
+      const transformedStream = stream12.pipeThrough(new TransformStream({
+        async transform(chunk4, controller) {
+          if (chunk4.type === "tool-input-start" && chunk4.toolName === "attemptCompletion") {
+            toolCallId = chunk4.id;
+            return;
+          }
+          if (chunk4.type === "tool-input-delta" && chunk4.id === toolCallId) {
+            return;
+          }
+          if (chunk4.type === "tool-call" && chunk4.toolName === "attemptCompletion" && (chunk4.toolCallId === toolCallId || toolCallId === "")) {
+            const parsedResult = await safeParseJSON({
+              text: chunk4.input,
+              schema: attemptCompletionSchema
+            });
+            if (!parsedResult.success) {
+              throw new InvalidToolInputError({
+                toolName: chunk4.toolName,
+                toolInput: chunk4.input,
+                cause: parsedResult.error
+              });
+            }
+            const { result: result2 } = parsedResult.value;
+            const newInput = {
+              ...parsedResult.value,
+              result: await ensureOutputSchema(model2, outputSchema2, result2)
+            };
+            controller.enqueue({
+              ...chunk4,
+              input: JSON.stringify(newInput)
+            });
+            toolCallId = "";
+            return;
+          }
+          controller.enqueue(chunk4);
+        }
+      }));
+      return {
+        stream: transformedStream,
+        ...rest
+      };
+    }
+  };
+}
+async function ensureOutputSchema(model2, schema7, content3) {
+  try {
+    const { object: object4 } = await generateObject({
+      model: model2,
+      schema: schema7,
+      prompt: [
+        "The model is trying to generate object with following schema:",
+        JSON.stringify(v4_default.toJSONSchema(schema7)),
+        "Current input is",
+        content3,
+        "Please fix the inputs."
+      ].join(`
+`),
+      maxRetries: 0
+    });
+    return JSON.stringify(object4);
+  } catch (err2) {
+    return content3;
+  }
+}
+
 // ../livekit/src/chat/models/ai-gateway.ts
 function createAiGatewayModel(llm) {
   const gateway2 = createGatewayProvider({
@@ -410479,6 +411221,7 @@ class FlexibleChatTransport {
   isCli;
   store;
   customAgent;
+  outputSchema;
   constructor(options6) {
     this.onStart = options6.onStart;
     this.getters = options6.getters;
@@ -410486,6 +411229,7 @@ class FlexibleChatTransport {
     this.isCli = options6.isCli;
     this.store = options6.store;
     this.customAgent = overrideCustomAgentTools(options6.customAgent);
+    this.outputSchema = options6.outputSchema;
   }
   sendMessages = async ({
     chatId,
@@ -410509,6 +411253,9 @@ class FlexibleChatTransport {
     if ("modelId" in llm && isWellKnownReasoningModel(llm.modelId)) {
       middlewares.push(createReasoningMiddleware());
     }
+    if (this.outputSchema) {
+      middlewares.push(createOutputSchemaMiddleware(this.outputSchema));
+    }
     if (llm.useToolCallMiddleware) {
       middlewares.push(createToolCallMiddleware());
     }
@@ -410637,6 +411384,7 @@ class LiveChatKit {
     isSubTask,
     isCli,
     customAgent,
+    outputSchema: outputSchema2,
     ...chatInit
   }) {
     this.taskId = taskId;
@@ -410647,7 +411395,8 @@ class LiveChatKit {
       getters,
       isSubTask,
       isCli,
-      customAgent
+      customAgent,
+      outputSchema: outputSchema2
     });
     this.chat = new (makeChatWithHookClass(store, chatClass))({
       ...chatInit,
@@ -411487,6 +412236,7 @@ class TaskRunner {
       isCli: true,
       isSubTask: options6.isSubTask,
       customAgent: options6.customAgent,
+      outputSchema: options6.outputSchema,
       getters: {
         getLLM: () => options6.llm,
         getEnvironment: async () => ({
@@ -411936,7 +412686,7 @@ var parsePositiveInt = (input2) => {
   }
   return result2;
 };
-var program5 = new Command().name("pochi").description(`${source_default.bold("Pochi")} v${package_default.version} - A powerful CLI tool for AI-driven development.`).optionsGroup("Prompt:").option("-p, --prompt <prompt>", "Create a new task with a given prompt. Input can also be piped. For example: `cat my-prompt.md | pochi`. Workflows can be triggered with `/workflow-name`, like `pochi -p /create-pr`.").optionsGroup("Options:").option("--stream-json", "Stream the output in JSON format. This is useful for parsing the output in scripts.").option("--max-steps <number>", "Set the maximum number of steps for a task. The task will stop if it exceeds this limit.", parsePositiveInt, 24).option("--max-retries <number>", "Set the maximum number of retries for a single step in a task.", parsePositiveInt, 3).optionsGroup("Model:").option("-m, --model <model>", "Specify the model to be used for the task.", "qwen/qwen3-coder").optionsGroup("MCP:").option("--no-mcp", "Disable MCP (Model Context Protocol) integration completely.").action(async (options6) => {
+var program5 = new Command().name("pochi").description(`${source_default.bold("Pochi")} v${package_default.version} - A powerful CLI tool for AI-driven development.`).optionsGroup("Prompt:").option("-p, --prompt <prompt>", "Create a new task with a given prompt. Input can also be piped. For example: `cat my-prompt.md | pochi`. Workflows can be triggered with `/workflow-name`, like `pochi -p /create-pr`.").optionsGroup("Options:").option("--stream-json", "Stream the output in JSON format. This is useful for parsing the output in scripts.").option("--max-steps <number>", "Set the maximum number of steps for a task. The task will stop if it exceeds this limit.", parsePositiveInt, 24).option("--max-retries <number>", "Set the maximum number of retries for a single step in a task.", parsePositiveInt, 3).addOption(new Option("--experimental-output-schema <schema>", "Specify a JSON schema for the output of the task. The task will be validated against this schema.").hideHelp()).optionsGroup("Model:").option("-m, --model <model>", "Specify the model to be used for the task.", "qwen/qwen3-coder").optionsGroup("MCP:").option("--no-mcp", "Disable MCP (Model Context Protocol) integration completely.").action(async (options6) => {
   const { uid, prompt: prompt3 } = await parseTaskInput(options6, program5);
   const store = await createStore3();
   const llm = await createLLMConfig(program5, options6);
@@ -411969,7 +412719,8 @@ var program5 = new Command().name("pochi").description(`${source_default.bold("P
     maxRetries: options6.maxRetries,
     onSubTaskCreated,
     customAgents,
-    mcpHub
+    mcpHub,
+    outputSchema: options6.experimentalOutputSchema ? parseOutputSchema(options6.experimentalOutputSchema) : undefined
   });
   const renderer = new OutputRenderer(runner.state);
   if (options6.streamJson) {
@@ -412148,3 +412899,7 @@ async function getModelFromWorkflow(options6) {
     }
   }
 }
+function parseOutputSchema(outputSchema2) {
+  const schema7 = Function("...args", `function getZodSchema(z) { return ${outputSchema2} }; return getZodSchema(...args);`)(v4_default);
+  return schema7;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpochi/cli",
-  "version": "0.5.59",
+  "version": "0.5.60",
   "type": "module",
   "bin": {
     "pochi": "dist/cli.js"
@@ -44,6 +44,7 @@
     "omelette": "^0.4.17",
     "ora": "^8.2.0",
     "remeda": "^2.21.3",
-    "semver": "^7.6.3"
+    "semver": "^7.6.3",
+    "zod": "^3.25.76"
   }
 }