@getpochi/cli 0.5.59 → 0.5.61

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,
@@ -347724,6 +347749,520 @@ var originalGenerateId = createIdGenerator({
   prefix: "aitxt",
   size: 24
 });
+async function generateText({
+  model: modelArg,
+  tools,
+  toolChoice,
+  system,
+  prompt,
+  messages,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  stopWhen = stepCountIs(1),
+  experimental_output: output,
+  experimental_telemetry: telemetry,
+  providerOptions,
+  experimental_activeTools,
+  activeTools = experimental_activeTools,
+  experimental_prepareStep,
+  prepareStep = experimental_prepareStep,
+  experimental_repairToolCall: repairToolCall,
+  experimental_download: download2,
+  experimental_context,
+  _internal: {
+    generateId: generateId3 = originalGenerateId,
+    currentDate = () => /* @__PURE__ */ new Date
+  } = {},
+  onStepFinish,
+  ...settings
+}) {
+  const model = resolveLanguageModel(modelArg);
+  const stopConditions = asArray(stopWhen);
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
+  const callSettings = prepareCallSettings(settings);
+  const headersWithUserAgent = withUserAgentSuffix(headers != null ? headers : {}, `ai/${VERSION3}`);
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    model,
+    telemetry,
+    headers: headersWithUserAgent,
+    settings: { ...callSettings, maxRetries }
+  });
+  const initialPrompt = await standardizePrompt({
+    system,
+    prompt,
+    messages
+  });
+  const tracer = getTracer(telemetry);
+  try {
+    return await recordSpan({
+      name: "ai.generateText",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({
+            operationId: "ai.generateText",
+            telemetry
+          }),
+          ...baseTelemetryAttributes,
+          "ai.model.provider": model.provider,
+          "ai.model.id": model.modelId,
+          "ai.prompt": {
+            input: () => JSON.stringify({ system, prompt, messages })
+          }
+        }
+      }),
+      tracer,
+      fn: async (span) => {
+        var _a172, _b8, _c, _d, _e, _f, _g;
+        const callSettings2 = prepareCallSettings(settings);
+        let currentModelResponse;
+        let clientToolCalls = [];
+        let clientToolOutputs = [];
+        const responseMessages = [];
+        const steps = [];
+        do {
+          const stepInputMessages = [
+            ...initialPrompt.messages,
+            ...responseMessages
+          ];
+          const prepareStepResult = await (prepareStep == null ? undefined : prepareStep({
+            model,
+            steps,
+            stepNumber: steps.length,
+            messages: stepInputMessages
+          }));
+          const promptMessages = await convertToLanguageModelPrompt({
+            prompt: {
+              system: (_a172 = prepareStepResult == null ? undefined : prepareStepResult.system) != null ? _a172 : initialPrompt.system,
+              messages: (_b8 = prepareStepResult == null ? undefined : prepareStepResult.messages) != null ? _b8 : stepInputMessages
+            },
+            supportedUrls: await model.supportedUrls,
+            download: download2
+          });
+          const stepModel = resolveLanguageModel((_c = prepareStepResult == null ? undefined : prepareStepResult.model) != null ? _c : model);
+          const { toolChoice: stepToolChoice, tools: stepTools } = prepareToolsAndToolChoice({
+            tools,
+            toolChoice: (_d = prepareStepResult == null ? undefined : prepareStepResult.toolChoice) != null ? _d : toolChoice,
+            activeTools: (_e = prepareStepResult == null ? undefined : prepareStepResult.activeTools) != null ? _e : activeTools
+          });
+          currentModelResponse = await retry(() => {
+            var _a18;
+            return recordSpan({
+              name: "ai.generateText.doGenerate",
+              attributes: selectTelemetryAttributes({
+                telemetry,
+                attributes: {
+                  ...assembleOperationName({
+                    operationId: "ai.generateText.doGenerate",
+                    telemetry
+                  }),
+                  ...baseTelemetryAttributes,
+                  "ai.model.provider": stepModel.provider,
+                  "ai.model.id": stepModel.modelId,
+                  "ai.prompt.messages": {
+                    input: () => stringifyForTelemetry(promptMessages)
+                  },
+                  "ai.prompt.tools": {
+                    input: () => stepTools == null ? undefined : stepTools.map((tool3) => JSON.stringify(tool3))
+                  },
+                  "ai.prompt.toolChoice": {
+                    input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : undefined
+                  },
+                  "gen_ai.system": stepModel.provider,
+                  "gen_ai.request.model": stepModel.modelId,
+                  "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
+                  "gen_ai.request.max_tokens": settings.maxOutputTokens,
+                  "gen_ai.request.presence_penalty": settings.presencePenalty,
+                  "gen_ai.request.stop_sequences": settings.stopSequences,
+                  "gen_ai.request.temperature": (_a18 = settings.temperature) != null ? _a18 : undefined,
+                  "gen_ai.request.top_k": settings.topK,
+                  "gen_ai.request.top_p": settings.topP
+                }
+              }),
+              tracer,
+              fn: async (span2) => {
+                var _a19, _b22, _c2, _d2, _e2, _f2, _g2, _h;
+                const result2 = await stepModel.doGenerate({
+                  ...callSettings2,
+                  tools: stepTools,
+                  toolChoice: stepToolChoice,
+                  responseFormat: output == null ? undefined : output.responseFormat,
+                  prompt: promptMessages,
+                  providerOptions,
+                  abortSignal,
+                  headers: headersWithUserAgent
+                });
+                const responseData = {
+                  id: (_b22 = (_a19 = result2.response) == null ? undefined : _a19.id) != null ? _b22 : generateId3(),
+                  timestamp: (_d2 = (_c2 = result2.response) == null ? undefined : _c2.timestamp) != null ? _d2 : currentDate(),
+                  modelId: (_f2 = (_e2 = result2.response) == null ? undefined : _e2.modelId) != null ? _f2 : stepModel.modelId,
+                  headers: (_g2 = result2.response) == null ? undefined : _g2.headers,
+                  body: (_h = result2.response) == null ? undefined : _h.body
+                };
+                span2.setAttributes(selectTelemetryAttributes({
+                  telemetry,
+                  attributes: {
+                    "ai.response.finishReason": result2.finishReason,
+                    "ai.response.text": {
+                      output: () => extractTextContent(result2.content)
+                    },
+                    "ai.response.toolCalls": {
+                      output: () => {
+                        const toolCalls = asToolCalls(result2.content);
+                        return toolCalls == null ? undefined : JSON.stringify(toolCalls);
+                      }
+                    },
+                    "ai.response.id": responseData.id,
+                    "ai.response.model": responseData.modelId,
+                    "ai.response.timestamp": responseData.timestamp.toISOString(),
+                    "ai.response.providerMetadata": JSON.stringify(result2.providerMetadata),
+                    "ai.usage.promptTokens": result2.usage.inputTokens,
+                    "ai.usage.completionTokens": result2.usage.outputTokens,
+                    "gen_ai.response.finish_reasons": [result2.finishReason],
+                    "gen_ai.response.id": responseData.id,
+                    "gen_ai.response.model": responseData.modelId,
+                    "gen_ai.usage.input_tokens": result2.usage.inputTokens,
+                    "gen_ai.usage.output_tokens": result2.usage.outputTokens
+                  }
+                }));
+                return { ...result2, response: responseData };
+              }
+            });
+          });
+          const stepToolCalls = await Promise.all(currentModelResponse.content.filter((part) => part.type === "tool-call").map((toolCall) => parseToolCall({
+            toolCall,
+            tools,
+            repairToolCall,
+            system,
+            messages: stepInputMessages
+          })));
+          for (const toolCall of stepToolCalls) {
+            if (toolCall.invalid) {
+              continue;
+            }
+            const tool3 = tools[toolCall.toolName];
+            if ((tool3 == null ? undefined : tool3.onInputAvailable) != null) {
+              await tool3.onInputAvailable({
+                input: toolCall.input,
+                toolCallId: toolCall.toolCallId,
+                messages: stepInputMessages,
+                abortSignal,
+                experimental_context
+              });
+            }
+          }
+          const invalidToolCalls = stepToolCalls.filter((toolCall) => toolCall.invalid && toolCall.dynamic);
+          clientToolOutputs = [];
+          for (const toolCall of invalidToolCalls) {
+            clientToolOutputs.push({
+              type: "tool-error",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.input,
+              error: getErrorMessage2(toolCall.error),
+              dynamic: true
+            });
+          }
+          clientToolCalls = stepToolCalls.filter((toolCall) => !toolCall.providerExecuted);
+          if (tools != null) {
+            clientToolOutputs.push(...await executeTools({
+              toolCalls: clientToolCalls.filter((toolCall) => !toolCall.invalid),
+              tools,
+              tracer,
+              telemetry,
+              messages: stepInputMessages,
+              abortSignal,
+              experimental_context
+            }));
+          }
+          const stepContent = asContent({
+            content: currentModelResponse.content,
+            toolCalls: stepToolCalls,
+            toolOutputs: clientToolOutputs
+          });
+          responseMessages.push(...toResponseMessages({
+            content: stepContent,
+            tools
+          }));
+          const currentStepResult = new DefaultStepResult({
+            content: stepContent,
+            finishReason: currentModelResponse.finishReason,
+            usage: currentModelResponse.usage,
+            warnings: currentModelResponse.warnings,
+            providerMetadata: currentModelResponse.providerMetadata,
+            request: (_f = currentModelResponse.request) != null ? _f : {},
+            response: {
+              ...currentModelResponse.response,
+              messages: structuredClone(responseMessages)
+            }
+          });
+          logWarnings((_g = currentModelResponse.warnings) != null ? _g : []);
+          steps.push(currentStepResult);
+          await (onStepFinish == null ? undefined : onStepFinish(currentStepResult));
+        } while (clientToolCalls.length > 0 && clientToolOutputs.length === clientToolCalls.length && !await isStopConditionMet({ stopConditions, steps }));
+        span.setAttributes(selectTelemetryAttributes({
+          telemetry,
+          attributes: {
+            "ai.response.finishReason": currentModelResponse.finishReason,
+            "ai.response.text": {
+              output: () => extractTextContent(currentModelResponse.content)
+            },
+            "ai.response.toolCalls": {
+              output: () => {
+                const toolCalls = asToolCalls(currentModelResponse.content);
+                return toolCalls == null ? undefined : JSON.stringify(toolCalls);
+              }
+            },
+            "ai.response.providerMetadata": JSON.stringify(currentModelResponse.providerMetadata),
+            "ai.usage.promptTokens": currentModelResponse.usage.inputTokens,
+            "ai.usage.completionTokens": currentModelResponse.usage.outputTokens
+          }
+        }));
+        const lastStep = steps[steps.length - 1];
+        return new DefaultGenerateTextResult({
+          steps,
+          resolvedOutput: await (output == null ? undefined : output.parseOutput({ text: lastStep.text }, {
+            response: lastStep.response,
+            usage: lastStep.usage,
+            finishReason: lastStep.finishReason
+          }))
+        });
+      }
+    });
+  } catch (error40) {
+    throw wrapGatewayError(error40);
+  }
+}
+async function executeTools({
+  toolCalls,
+  tools,
+  tracer,
+  telemetry,
+  messages,
+  abortSignal,
+  experimental_context
+}) {
+  const toolOutputs = await Promise.all(toolCalls.map(async ({ toolCallId, toolName, input }) => {
+    const tool3 = tools[toolName];
+    if ((tool3 == null ? undefined : tool3.execute) == null) {
+      return;
+    }
+    return recordSpan({
+      name: "ai.toolCall",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({
+            operationId: "ai.toolCall",
+            telemetry
+          }),
+          "ai.toolCall.name": toolName,
+          "ai.toolCall.id": toolCallId,
+          "ai.toolCall.args": {
+            output: () => JSON.stringify(input)
+          }
+        }
+      }),
+      tracer,
+      fn: async (span) => {
+        try {
+          const stream = executeTool({
+            execute: tool3.execute.bind(tool3),
+            input,
+            options: {
+              toolCallId,
+              messages,
+              abortSignal,
+              experimental_context
+            }
+          });
+          let output;
+          for await (const part of stream) {
+            if (part.type === "final") {
+              output = part.output;
+            }
+          }
+          try {
+            span.setAttributes(selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                "ai.toolCall.result": {
+                  output: () => JSON.stringify(output)
+                }
+              }
+            }));
+          } catch (ignored) {}
+          return {
+            type: "tool-result",
+            toolCallId,
+            toolName,
+            input,
+            output,
+            dynamic: tool3.type === "dynamic"
+          };
+        } catch (error40) {
+          recordErrorOnSpan(span, error40);
+          return {
+            type: "tool-error",
+            toolCallId,
+            toolName,
+            input,
+            error: error40,
+            dynamic: tool3.type === "dynamic"
+          };
+        }
+      }
+    });
+  }));
+  return toolOutputs.filter((output) => output != null);
+}
+var DefaultGenerateTextResult = class {
+  constructor(options) {
+    this.steps = options.steps;
+    this.resolvedOutput = options.resolvedOutput;
+  }
+  get finalStep() {
+    return this.steps[this.steps.length - 1];
+  }
+  get content() {
+    return this.finalStep.content;
+  }
+  get text() {
+    return this.finalStep.text;
+  }
+  get files() {
+    return this.finalStep.files;
+  }
+  get reasoningText() {
+    return this.finalStep.reasoningText;
+  }
+  get reasoning() {
+    return this.finalStep.reasoning;
+  }
+  get toolCalls() {
+    return this.finalStep.toolCalls;
+  }
+  get staticToolCalls() {
+    return this.finalStep.staticToolCalls;
+  }
+  get dynamicToolCalls() {
+    return this.finalStep.dynamicToolCalls;
+  }
+  get toolResults() {
+    return this.finalStep.toolResults;
+  }
+  get staticToolResults() {
+    return this.finalStep.staticToolResults;
+  }
+  get dynamicToolResults() {
+    return this.finalStep.dynamicToolResults;
+  }
+  get sources() {
+    return this.finalStep.sources;
+  }
+  get finishReason() {
+    return this.finalStep.finishReason;
+  }
+  get warnings() {
+    return this.finalStep.warnings;
+  }
+  get providerMetadata() {
+    return this.finalStep.providerMetadata;
+  }
+  get response() {
+    return this.finalStep.response;
+  }
+  get request() {
+    return this.finalStep.request;
+  }
+  get usage() {
+    return this.finalStep.usage;
+  }
+  get totalUsage() {
+    return this.steps.reduce((totalUsage, step) => {
+      return addLanguageModelUsage(totalUsage, step.usage);
+    }, {
+      inputTokens: undefined,
+      outputTokens: undefined,
+      totalTokens: undefined,
+      reasoningTokens: undefined,
+      cachedInputTokens: undefined
+    });
+  }
+  get experimental_output() {
+    if (this.resolvedOutput == null) {
+      throw new NoOutputSpecifiedError;
+    }
+    return this.resolvedOutput;
+  }
+};
+function asToolCalls(content) {
+  const parts = content.filter((part) => part.type === "tool-call");
+  if (parts.length === 0) {
+    return;
+  }
+  return parts.map((toolCall) => ({
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: toolCall.input
+  }));
+}
+function asContent({
+  content,
+  toolCalls,
+  toolOutputs
+}) {
+  return [
+    ...content.map((part) => {
+      switch (part.type) {
+        case "text":
+        case "reasoning":
+        case "source":
+          return part;
+        case "file": {
+          return {
+            type: "file",
+            file: new DefaultGeneratedFile(part)
+          };
+        }
+        case "tool-call": {
+          return toolCalls.find((toolCall) => toolCall.toolCallId === part.toolCallId);
+        }
+        case "tool-result": {
+          const toolCall = toolCalls.find((toolCall2) => toolCall2.toolCallId === part.toolCallId);
+          if (toolCall == null) {
+            throw new Error(`Tool call ${part.toolCallId} not found.`);
+          }
+          if (part.isError) {
+            return {
+              type: "tool-error",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: toolCall.input,
+              error: part.result,
+              providerExecuted: true,
+              dynamic: toolCall.dynamic
+            };
+          }
+          return {
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            input: toolCall.input,
+            output: part.result,
+            providerExecuted: true,
+            dynamic: toolCall.dynamic
+          };
+        }
+      }
+    }),
+    ...toolOutputs
+  ];
+}
 function prepareHeaders(headers, defaultHeaders) {
   const responseHeaders = new Headers(headers != null ? headers : {});
   for (const [key, value2] of Object.entries(defaultHeaders)) {
@@ -350721,7 +351260,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 +353279,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.")
   })
@@ -358795,7 +359979,6 @@ function createModel(vendorId, opts) {
 
 // ../vendor-pochi/src/model.ts
 function createPochiModel({
-  id,
   modelId,
   getCredentials
 }) {
@@ -358804,11 +359987,28 @@ function createPochiModel({
     provider: "pochi",
     modelId: modelId || "<default>",
     supportedUrls: {},
-    doGenerate: async () => Promise.reject("Not implemented"),
-    doStream: async ({ prompt, abortSignal, stopSequences, tools }) => {
+    doGenerate: async ({ headers, ...options }) => {
+      const apiClient = createApiClient(getCredentials);
+      const resp = await apiClient.api.chat.$post({
+        json: {
+          model: modelId,
+          options
+        }
+      }, {
+        headers: headers ? i5(headers, (x) => x || "") : undefined
+      });
+      const data = await resp.json();
+      return data;
+    },
+    doStream: async ({
+      prompt,
+      abortSignal,
+      stopSequences,
+      tools,
+      headers
+    }) => {
       const apiClient = createApiClient(getCredentials);
       const data = {
-        id,
         model: modelId,
         callOptions: {
           prompt: convertFilePartDataToBase64(prompt),
@@ -358819,6 +360019,7 @@ function createPochiModel({
       const resp = await apiClient.api.chat.stream.$post({
         json: data
       }, {
+        headers: headers ? i5(headers, (x) => x || "") : undefined,
         init: {
           signal: abortSignal
         }
@@ -367770,7 +368971,7 @@ var {
 // package.json
 var package_default = {
   name: "@getpochi/cli",
-  version: "0.5.59",
+  version: "0.5.61",
   type: "module",
   bin: {
     pochi: "src/cli.ts"
@@ -367814,7 +369015,8 @@ var package_default = {
     omelette: "^0.4.17",
     ora: "^8.2.0",
     remeda: "catalog:",
-    semver: "^7.6.3"
+    semver: "^7.6.3",
+    zod: "catalog:"
   }
 };
 
@@ -409171,6 +410373,9 @@ function toTaskError(error46) {
   return internalError(error46.message);
 }
 
+// ../common/src/pochi-api.ts
+var PochiTaskIdHeader = "x-pochi-task-id";
+
 // ../livekit/src/chat/llm/generate-task-title.ts
 var logger18 = getLogger("generateTaskTitle");
 async function generateTaskTitle(options6) {
@@ -409182,6 +410387,7 @@ async function generateTaskTitle(options6) {
   return newTitle;
 }
 async function generateTaskTitleImpl({
+  taskId,
   title,
   messages: messages2,
   getModel,
@@ -409199,7 +410405,7 @@ async function generateTaskTitleImpl({
   if (partCount >= 5 && partCount < 20 && !isTitleGeneratedByLlm(title, titleFromMessages)) {
     try {
       const model2 = getModel();
-      const title2 = await generateTitle2(model2, messages2, abortSignal);
+      const title2 = await generateTitle2(taskId, model2, messages2, abortSignal);
       if (title2.length > 0) {
         return title2;
       }
@@ -409225,7 +410431,7 @@ function getTitleFromMessages(messages2) {
 function isTitleGeneratedByLlm(title, titleFromMessages) {
   return title !== titleFromMessages;
 }
-async function generateTitle2(model2, inputMessages, abortSignal) {
+async function generateTitle2(taskId, model2, inputMessages, abortSignal) {
   const messages2 = [
     ...inputMessages,
     {
@@ -409239,14 +410445,17 @@ async function generateTitle2(model2, inputMessages, abortSignal) {
       ]
     }
   ];
-  const stream12 = streamText({
+  const resp = await generateText({
+    headers: {
+      [PochiTaskIdHeader]: taskId
+    },
     model: model2,
     prompt: convertToModelMessages(formatters.llm(messages2, { removeSystemReminder: true })),
     abortSignal,
     maxOutputTokens: 50,
     maxRetries: 0
   });
-  return (await stream12.text).trim();
+  return resp.text;
 }
 
 // ../livekit/src/chat/background-job/manager.ts
@@ -409293,6 +410502,7 @@ async function process16({
     return;
   }
   const newTitle = await generateTaskTitle({
+    taskId,
     title: task.title,
     messages: messages2,
     getModel
@@ -409379,56 +410589,33 @@ async function digest(data) {
 }
 
 // ../livekit/src/chat/llm/repair-tool-call.ts
-var logger21 = getLogger("RepairToolCall");
-var makeRepairToolCall = (model2) => async ({ toolCall, inputSchema: inputSchema2, error: error46 }) => {
+var makeRepairToolCall = (taskId, model2) => async ({ toolCall, inputSchema: inputSchema2, error: error46 }) => {
   if (NoSuchToolError.isInstance(error46)) {
     return null;
   }
-  const result2 = await streamText({
+  const tools = createClientTools();
+  const tool2 = tools[toolCall.toolName];
+  const { object: repairedArgs } = await generateObject({
+    headers: {
+      [PochiTaskIdHeader]: taskId
+    },
     model: model2,
+    schema: tool2.inputSchema,
     prompt: [
-      `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
+      `The model tried to call the tool "${toolCall.toolName}" with the following inputs:`,
       JSON.stringify(toolCall.input),
       "The tool accepts the following schema:",
       JSON.stringify(inputSchema2(toolCall)),
-      "Please fix the arguments. Please ONLY output the json string, without any other text (no markdown code block wrapper, either)",
-      "",
-      "<good-example>",
-      '{"path": "./src/file.ts", "content": "console.log("hello");"}',
-      "</good-example>",
-      "",
-      "<bad-example>",
-      "```json",
-      '{"path": "./src/file.ts", "content": "console.log("hello");"}',
-      "```",
-      "</bad-example>",
-      "",
-      "<bad-example>",
-      "Here is the corrected JSON:",
-      '{"path": "./src/file.ts", "content": "console.log("hello");"}',
-      "</bad-example>",
-      "",
-      "<bad-example>",
-      "```",
-      '{"path": "./src/file.ts", "content": "console.log("hello");"}',
-      "```",
-      "</bad-example>",
-      "",
-      "<bad-example>",
-      '{"path": "./src/file.ts", "content": "console.log("hello");"} // Fixed arguments',
-      "</bad-example>"
+      "Please fix the inputs."
     ].join(`
-`),
-    maxOutputTokens: 3000,
-    maxRetries: 0
+`)
   });
-  const input2 = await result2.text;
-  logger21.debug("Repairing tool call:", toolCall.toolName, input2);
-  return { ...toolCall, input: input2 };
+  return { ...toolCall, input: JSON.stringify(repairedArgs) };
 };
 // ../livekit/src/chat/llm/compact-task.ts
-var logger22 = getLogger("compactTask");
+var logger21 = getLogger("compactTask");
 async function compactTask({
+  taskId,
   model: model2,
   messages: messages2,
   abortSignal,
@@ -409439,7 +410626,7 @@ async function compactTask({
     throw new Error("No messages to compact");
   }
   try {
-    const text20 = prompts.inlineCompact(await createSummary(model2, abortSignal, messages2.slice(0, -1)), messages2.length - 1);
+    const text20 = prompts.inlineCompact(await createSummary(taskId, model2, abortSignal, messages2.slice(0, -1)), messages2.length - 1);
     if (inline) {
       lastMessage.parts.unshift({
         type: "text",
@@ -409449,10 +410636,10 @@ async function compactTask({
     }
     return text20;
   } catch (err2) {
-    logger22.warn("Failed to create summary", err2);
+    logger21.warn("Failed to create summary", err2);
   }
 }
-async function createSummary(model2, abortSignal, inputMessages) {
+async function createSummary(taskId, model2, abortSignal, inputMessages) {
   const messages2 = [
     ...inputMessages,
     {
@@ -409466,7 +410653,10 @@ async function createSummary(model2, abortSignal, inputMessages) {
       ]
     }
   ];
-  const stream12 = streamText({
+  const resp = await generateText({
+    headers: {
+      [PochiTaskIdHeader]: taskId
+    },
     model: model2,
     prompt: convertToModelMessages(formatters.llm(messages2, {
       removeSystemReminder: true
@@ -409475,7 +410665,7 @@ async function createSummary(model2, abortSignal, inputMessages) {
     maxOutputTokens: 3000,
     maxRetries: 0
   });
-  return stream12.text;
+  return resp.text;
 }
 // ../livekit/src/chat/mcp-utils.ts
 function parseMcpToolSet(store, mcpToolSet) {
@@ -410199,6 +411389,80 @@ function createStopWordStream(stop3) {
     }
   });
 }
+// ../livekit/src/chat/middlewares/output-schema-middleware.ts
+function createOutputSchemaMiddleware(taskId, model2, outputSchema2) {
+  return {
+    middlewareVersion: "v2",
+    wrapStream: async ({ doStream }) => {
+      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(taskId, model2, outputSchema2, result2)
+            };
+            controller.enqueue({
+              ...chunk4,
+              input: JSON.stringify(newInput)
+            });
+            toolCallId = "";
+            return;
+          }
+          controller.enqueue(chunk4);
+        }
+      }));
+      return {
+        stream: transformedStream,
+        ...rest
+      };
+    }
+  };
+}
+async function ensureOutputSchema(taskId, model2, schema7, content3) {
+  try {
+    const { object: object4 } = await generateObject({
+      headers: {
+        [PochiTaskIdHeader]: taskId
+      },
+      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({
@@ -410355,7 +411619,7 @@ function createGoogleVertexTuningModel(llm) {
 }
 
 // ../livekit/src/chat/models/openai.ts
-var logger23 = getLogger("openai");
+var logger22 = getLogger("openai");
 var OpenAIRequestParamsSchema = exports_external.object({
   max_tokens: exports_external.number().positive().optional(),
   max_completion_tokens: exports_external.number().positive().optional()
@@ -410405,7 +411669,7 @@ function overrideMaxOutputToken(body3) {
     const json10 = JSON.parse(body3);
     const result2 = OpenAIRequestParamsSchema.safeParse(json10);
     if (!result2.success) {
-      logger23.error("OpenAI request body validation failed:", result2.error);
+      logger22.error("OpenAI request body validation failed:", result2.error);
       return;
     }
     const parsed = result2.data;
@@ -410414,7 +411678,7 @@ function overrideMaxOutputToken(body3) {
     }
     return JSON.stringify(parsed);
   } catch (error46) {
-    logger23.error("Failed to parse OpenAI request body:", error46);
+    logger22.error("Failed to parse OpenAI request body:", error46);
   }
   return;
 }
@@ -410443,12 +411707,9 @@ function createOpenAIResponsesModel(llm) {
 }
 
 // ../livekit/src/chat/models/index.ts
-function createModel2({
-  id: id5,
-  llm
-}) {
+function createModel2({ llm }) {
   if (llm.type === "vendor") {
-    return llm.getModel(id5);
+    return llm.getModel();
   }
   if (llm.type === "openai") {
     return createOpenAIModel(llm);
@@ -410479,6 +411740,7 @@ class FlexibleChatTransport {
   isCli;
   store;
   customAgent;
+  outputSchema;
   constructor(options6) {
     this.onStart = options6.onStart;
     this.getters = options6.getters;
@@ -410486,6 +411748,7 @@ class FlexibleChatTransport {
     this.isCli = options6.isCli;
     this.store = options6.store;
     this.customAgent = overrideCustomAgentTools(options6.customAgent);
+    this.outputSchema = options6.outputSchema;
   }
   sendMessages = async ({
     chatId,
@@ -410502,6 +411765,7 @@ class FlexibleChatTransport {
       abortSignal,
       getters: this.getters
     });
+    const model2 = createModel2({ llm });
     const middlewares = [];
     if (!this.isSubTask) {
       middlewares.push(createNewTaskMiddleware(this.store, environment2?.info.cwd, chatId, customAgents));
@@ -410509,6 +411773,9 @@ class FlexibleChatTransport {
     if ("modelId" in llm && isWellKnownReasoningModel(llm.modelId)) {
       middlewares.push(createReasoningMiddleware());
     }
+    if (this.outputSchema) {
+      middlewares.push(createOutputSchemaMiddleware(chatId, model2, this.outputSchema));
+    }
     if (llm.useToolCallMiddleware) {
       middlewares.push(createToolCallMiddleware());
     }
@@ -410527,8 +411794,10 @@ class FlexibleChatTransport {
       return true;
     });
     const preparedMessages = await prepareMessages(messages2, environment2);
-    const model2 = createModel2({ id: chatId, llm });
     const stream12 = streamText({
+      headers: {
+        [PochiTaskIdHeader]: chatId
+      },
       system: prompts.system(environment2?.info?.customRules, this.customAgent, mcpInfo?.instructions),
       messages: convertToModelMessages(formatters.llm(preparedMessages), { tools }),
       model: wrapLanguageModel({
@@ -410539,7 +411808,7 @@ class FlexibleChatTransport {
       tools,
       maxRetries: 0,
       onError: () => {},
-      experimental_repairToolCall: makeRepairToolCall(model2),
+      experimental_repairToolCall: makeRepairToolCall(chatId, model2),
       experimental_download: async (items) => {
         const promises5 = items.map(async ({
           url: url3,
@@ -410619,7 +411888,7 @@ function estimateTotalTokens(messages2) {
 }
 
 // ../livekit/src/chat/live-chat-kit.ts
-var logger24 = getLogger("LiveChatKit");
+var logger23 = getLogger("LiveChatKit");
 
 class LiveChatKit {
   taskId;
@@ -410637,6 +411906,7 @@ class LiveChatKit {
     isSubTask,
     isCli,
     customAgent,
+    outputSchema: outputSchema2,
     ...chatInit
   }) {
     this.taskId = taskId;
@@ -410647,7 +411917,8 @@ class LiveChatKit {
       getters,
       isSubTask,
       isCli,
-      customAgent
+      customAgent,
+      outputSchema: outputSchema2
     });
     this.chat = new (makeChatWithHookClass(store, chatClass))({
       ...chatInit,
@@ -410667,15 +411938,16 @@ class LiveChatKit {
       const lastMessage = messages2.at(-1);
       if (lastMessage?.role === "user" && lastMessage.metadata?.kind === "user" && lastMessage.metadata.compact) {
         try {
-          const model2 = createModel2({ id: taskId, llm: getters.getLLM() });
+          const model2 = createModel2({ llm: getters.getLLM() });
           await compactTask({
+            taskId: this.taskId,
             model: model2,
             messages: messages2,
             abortSignal: abortSignal2,
             inline: true
           });
         } catch (err2) {
-          logger24.error("Failed to compact task", err2);
+          logger23.error("Failed to compact task", err2);
           throw err2;
         }
       }
@@ -410686,8 +411958,9 @@ class LiveChatKit {
     this.spawn = async () => {
       const taskId2 = crypto.randomUUID();
       const { messages: messages2 } = this.chat;
-      const model2 = createModel2({ id: taskId2, llm: getters.getLLM() });
+      const model2 = createModel2({ llm: getters.getLLM() });
       const summary6 = await compactTask({
+        taskId: taskId2,
         model: model2,
         messages: messages2,
         abortSignal
@@ -410769,7 +412042,7 @@ class LiveChatKit {
       if (!task) {
         throw new Error("Task not found");
       }
-      const getModel = () => createModel2({ id: this.taskId, llm: getters.getLLM() });
+      const getModel = () => createModel2({ llm: getters.getLLM() });
       scheduleGenerateTitleJob({
         taskId: this.taskId,
         store,
@@ -410814,7 +412087,7 @@ class LiveChatKit {
     }));
   };
   onError = (error46) => {
-    logger24.error("onError", error46);
+    logger23.error("onError", error46);
     const lastMessage = this.chat.messages.at(-1) || null;
     this.store.commit(events.chatStreamFailed({
       id: this.taskId,
@@ -410967,7 +412240,7 @@ import * as nodePath from "node:path";
 
 // ../common/src/diff-utils.ts
 var import_fast_levenshtein = __toESM(require_levenshtein(), 1);
-var logger25 = getLogger("diffUtils");
+var logger24 = getLogger("diffUtils");
 function normalize6(content3) {
   return content3.replace(/\r\n/g, `
 `).trimEnd();
@@ -410980,7 +412253,7 @@ class DiffError extends Error {
   }
 }
 async function parseDiffAndApply(fileContent3, searchContent, replaceContent, expectedReplacements = 1) {
-  logger25.trace(`Applying diff with expectedReplacements: ${expectedReplacements}`);
+  logger24.trace(`Applying diff with expectedReplacements: ${expectedReplacements}`);
   const isCRLF = fileContent3.includes(`\r
 `);
   const normalizedFileContent = normalize6(fileContent3);
@@ -410997,11 +412270,11 @@ async function parseDiffAndApply(fileContent3, searchContent, replaceContent, ex
   const matches2 = searchContentExact(normalizedFileContent, normalizedSearchContent);
   if (matches2.length < expectedReplacements) {
     matches2.push(...searchContentWithLineTrimmed(normalizedFileContent, normalizedSearchContent));
-    logger25.trace(`Found ${matches2.length} matches after line trimming search strategy`);
+    logger24.trace(`Found ${matches2.length} matches after line trimming search strategy`);
   }
   if (matches2.length < expectedReplacements) {
     matches2.push(...searchContentByBlockAnchor(normalizedFileContent, normalizedSearchContent));
-    logger25.trace(`Found ${matches2.length} matches after block anchor search strategy`);
+    logger24.trace(`Found ${matches2.length} matches after block anchor search strategy`);
   }
   if (matches2.length === 0) {
     throw new DiffError("Search content does not match the file content. Try to reread the file for the latest content.");
@@ -411010,7 +412283,7 @@ async function parseDiffAndApply(fileContent3, searchContent, replaceContent, ex
     throw new DiffError(`Expected ${expectedReplacements} occurrences but found ${matches2.length}. Please verify the search content and expectedReplacements parameter.`);
   }
   const result2 = replaceMatches(normalizedFileContent, matches2, replaceContent);
-  logger25.trace("Successfully applied diff");
+  logger24.trace("Successfully applied diff");
   if (isCRLF) {
     return result2.replace(/\n/g, `\r
 `);
@@ -411364,11 +412637,11 @@ var readFile13 = () => async ({ path: path27, startLine, endLine }, { cwd: cwd2
 
 // src/tools/search-files.ts
 import * as fs14 from "node:fs";
-var logger26 = getLogger("searchFiles");
+var logger25 = getLogger("searchFiles");
 var searchFiles2 = (context15) => async ({ path: path27, regex: regex3, filePattern }, { abortSignal, cwd: cwd2 }) => {
   const rgPath = context15.rg;
   if (!rgPath || !fs14.existsSync(rgPath)) {
-    logger26.error("Ripgrep not found at path", rgPath);
+    logger25.error("Ripgrep not found at path", rgPath);
     throw new Error(`Ripgrep not found at path: ${rgPath}`);
   }
   return await searchFilesWithRipgrep(path27, regex3, rgPath, cwd2, filePattern, abortSignal);
@@ -411446,7 +412719,7 @@ async function executeToolCall(tool2, options6, cwd2, abortSignal) {
 }
 
 // src/task-runner.ts
-var logger27 = getLogger("TaskRunner");
+var logger26 = getLogger("TaskRunner");
 
 class TaskRunner {
   cwd;
@@ -411487,6 +412760,7 @@ class TaskRunner {
       isCli: true,
       isSubTask: options6.isSubTask,
       customAgent: options6.customAgent,
+      outputSchema: options6.outputSchema,
       getters: {
         getLLM: () => options6.llm,
         getEnvironment: async () => ({
@@ -411522,9 +412796,9 @@ class TaskRunner {
     return this.chatKit.task?.shareId;
   }
   async run() {
-    logger27.debug("Starting TaskRunner...");
+    logger26.debug("Starting TaskRunner...");
     try {
-      logger27.trace("Start step loop.");
+      logger26.trace("Start step loop.");
       this.stepCount.reset();
       while (true) {
         const stepResult = await this.step();
@@ -411539,7 +412813,7 @@ class TaskRunner {
       }
     } catch (e11) {
       const error46 = toError2(e11);
-      logger27.trace("Failed:", error46);
+      logger26.trace("Failed:", error46);
     }
   }
   async step() {
@@ -411577,24 +412851,24 @@ class TaskRunner {
       throw new Error("Task is not loaded");
     }
     if ((task.status === "completed" || task.status === "pending-input") && isResultMessage(message)) {
-      logger27.trace("Task is completed or pending input, no more steps to process.");
+      logger26.trace("Task is completed or pending input, no more steps to process.");
       return "finished";
     }
     if (task.status === "failed") {
       if (task.error?.kind === "APICallError" && !task.error.isRetryable) {
         return "finished";
       }
-      logger27.error("Task is failed, trying to resend last message to resume it.", task.error);
+      logger26.error("Task is failed, trying to resend last message to resume it.", task.error);
       return "retry";
     }
     if (message.role !== "assistant") {
-      logger27.trace("Last message is not a assistant message, resending it to resume the task.");
+      logger26.trace("Last message is not a assistant message, resending it to resume the task.");
       return "retry";
     }
     if (isAssistantMessageWithEmptyParts(message) || isAssistantMessageWithPartialToolCalls(message) || isAssistantMessageWithOutputError(message) || lastAssistantMessageIsCompleteWithToolCalls({
       messages: this.chat.messages
     })) {
-      logger27.trace("Last message is assistant with empty parts or partial/completed tool calls, resending it to resume the task.");
+      logger26.trace("Last message is assistant with empty parts or partial/completed tool calls, resending it to resume the task.");
       const processed = prepareLastMessageForRetry(message);
       if (processed) {
         this.chat.appendOrReplaceMessage(processed);
@@ -411602,28 +412876,28 @@ class TaskRunner {
       return "retry";
     }
     if (isAssistantMessageWithNoToolCalls(message)) {
-      logger27.trace("Last message is assistant with no tool calls, sending a new user reminder.");
+      logger26.trace("Last message is assistant with no tool calls, sending a new user reminder.");
       const message2 = createUserMessage(prompts.createSystemReminder("You should use tool calls to answer the question, for example, use attemptCompletion if the job is done, or use askFollowupQuestions to clarify the request."));
       this.chat.appendOrReplaceMessage(message2);
       return "retry";
     }
   }
   async processToolCalls(message) {
-    logger27.trace("Processing tool calls in the last message.");
+    logger26.trace("Processing tool calls in the last message.");
     for (const toolCall of message.parts.filter(isToolUIPart)) {
       if (toolCall.state !== "input-available")
         continue;
       const toolName = getToolName(toolCall);
-      logger27.trace(`Found tool call: ${toolName} with args: ${JSON.stringify(toolCall.input)}`);
+      logger26.trace(`Found tool call: ${toolName} with args: ${JSON.stringify(toolCall.input)}`);
       const toolResult = await executeToolCall(toolCall, this.toolCallOptions, this.cwd);
       await this.chatKit.chat.addToolResult({
         tool: toolName,
         toolCallId: toolCall.toolCallId,
         output: toolResult
       });
-      logger27.trace(`Tool call result: ${JSON.stringify(toolResult)}`);
+      logger26.trace(`Tool call result: ${JSON.stringify(toolResult)}`);
     }
-    logger27.trace("All tool calls processed in the last message.");
+    logger26.trace("All tool calls processed in the last message.");
     return "next";
   }
 }
@@ -411924,8 +413198,8 @@ function registerUpgradeCommand(program5) {
   });
 }
 // src/cli.ts
-var logger28 = getLogger("Pochi");
-logger28.debug(`pochi v${package_default.version}`);
+var logger27 = getLogger("Pochi");
+logger27.debug(`pochi v${package_default.version}`);
 var parsePositiveInt = (input2) => {
   if (!input2) {
     return program5.error("The value for this option must be a positive integer.");
@@ -411936,7 +413210,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 +413243,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) {
@@ -412047,8 +413322,7 @@ async function createLLMConfigWithVendors(program6, model2) {
     return {
       type: "vendor",
       useToolCallMiddleware: options6.useToolCallMiddleware,
-      getModel: (id5) => createModel(vendorId, {
-        id: id5,
+      getModel: () => createModel(vendorId, {
         modelId,
         getCredentials: vendor2.getCredentials
       })
@@ -412064,8 +413338,7 @@ async function createLLMConfigWithPochi(model2) {
     return {
       type: "vendor",
       useToolCallMiddleware: pochiModelOptions.useToolCallMiddleware,
-      getModel: (id5) => createModel(vendorId, {
-        id: id5,
+      getModel: () => createModel(vendorId, {
         modelId: model2,
         getCredentials: vendor2.getCredentials
       })
@@ -412148,3 +413421,7 @@ async function getModelFromWorkflow(options6) {
     }
   }
 }
+function parseOutputSchema(outputSchema2) {
+  const schema7 = Function("...args", `function getZodSchema(z) { return ${outputSchema2} }; return getZodSchema(...args);`)(v4_default);
+  return schema7;
+}