@algolia/wizard 0.91.0 → 0.93.0

package/dist/main.js

@@ -1817,7 +1817,21 @@ function agentRunMetrics(event, values, tags) {
       value: Number(event.attempt > FIRST_ATTEMPT),
       type: COUNT_METRIC,
       tags: runTags
-    }
+    },
+    ...event.stepCount === void 0 ? [] : [
+      {
+        name: "wizard.agent.step_count",
+        value: event.stepCount,
+        type: GAUGE_METRIC,
+        tags: runTags
+      },
+      {
+        name: "wizard.agent.step_limit_hit",
+        value: Number(event.hitStepLimit === true),
+        type: COUNT_METRIC,
+        tags: runTags
+      }
+    ]
   ];
 }
 function trackAgentRun(event) {
@@ -1845,6 +1859,9 @@ function trackAgentRun(event) {
           thinking: profile.thinking,
           attempt: event.attempt,
           durationMs: event.durationMs,
+          stepCount: event.stepCount,
+          hitStepLimit: event.hitStepLimit,
+          finishReason: event.finishReason,
           workflow_id: AGENT_TELEMETRY_CONTEXT.workflowId,
           app_id: AGENT_TELEMETRY_CONTEXT.appId,
           ...values
@@ -2367,7 +2384,7 @@ async function ensureApplication(resumeAppId) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.91.0",
+  version: "0.93.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -5265,13 +5282,37 @@ function isProxyInactivityRejection(err) {
   const cause = RetryError.isInstance(err) ? err.lastError : err;
   return APICallError.isInstance(cause) && cause.statusCode === 401 && cause.responseBody === PROXY_REJECTION_BODY && cause.responseHeaders?.[PROXY_AUTH_REJECTED_HEADER2] === void 0;
 }
+var INCOMPLETE_CAUSES = {
+  stepLimit: {
+    kind: "missingReportAtStepLimit",
+    reason: "reached its step limit"
+  },
+  truncated: {
+    kind: "missingReportTruncated",
+    reason: "was cut off by the output token limit"
+  },
+  stopped: {
+    kind: "missingReportStopped",
+    reason: "stopped before it finished"
+  }
+};
+var INCOMPLETE_CAUSE_ENTRIES = Object.values(INCOMPLETE_CAUSES);
+function incompleteReasonOf(kind) {
+  return INCOMPLETE_CAUSE_ENTRIES.find((entry) => entry.kind === kind)?.reason;
+}
 var MissingReportError = class extends Error {
-  atStepLimit;
-  constructor(atStepLimit) {
+  incompleteCause;
+  constructor(incompleteCause) {
     super(MISSING_REPORT_STATUS_ERROR_MESSAGE);
-    this.atStepLimit = atStepLimit;
+    this.incompleteCause = incompleteCause;
   }
 };
+function incompleteCauseOf(stepCount, maxSteps, finishReason) {
+  if (stepCount >= maxSteps) return "stepLimit";
+  if (finishReason === "length") return "truncated";
+  if (finishReason !== "stop") return "stopped";
+  return null;
+}
 var AgentReportedFailureError = class extends Error {
   reason;
   constructor(reason) {
@@ -5297,11 +5338,11 @@ function withCachedHistory(messages) {
   ];
 }
 function isMissingReportRetry(kind) {
-  return kind === "missingReport" || kind === "missingReportAtStepLimit";
+  return kind === "missingReport" || incompleteReasonOf(kind) !== void 0;
 }
 function retryKind(err) {
   if (err instanceof MissingReportError) {
-    return err.atStepLimit ? "missingReportAtStepLimit" : "missingReport";
+    return err.incompleteCause ? INCOMPLETE_CAUSES[err.incompleteCause].kind : "missingReport";
   }
   if (NoOutputGeneratedError.isInstance(err)) return "transientProvider";
   if (APICallError.isInstance(err) && err.isRetryable) {
@@ -5335,7 +5376,9 @@ async function runAgentAttempt(req, attempt, retryReason) {
   const profileName = req.modelProfile ?? "implementation" /* implementation */;
   const profile = getModelProfile(profileName);
   const profileOptions = providerOptionsForProfile(profileName);
+  const maxSteps = req.maxSteps ?? profile.maxSteps;
   const forceReport = retryReason === "missingReport";
+  const incompleteReason = incompleteReasonOf(retryReason);
   const modelOptions = forceReport ? { thinking: { type: "disabled" } } : profileOptions;
   logger.info(
     {
@@ -5376,8 +5419,8 @@ async function runAgentAttempt(req, attempt, retryReason) {
       "The previous attempt ended without reportStatus. Do not repeat side effects. Use the available read tools to inspect existing work if needed, then call reportStatus."
     ] : [
       "The previous attempt ended without reportStatus. Do not repeat side effects. Call reportStatus now."
-    ] : retryReason === "missingReportAtStepLimit" ? [
-      "The previous attempt reached its step limit without reportStatus and may be incomplete. Inspect existing work, finish only the remaining work, avoid repeated side effects, and call reportStatus."
+    ] : incompleteReason ? [
+      `The previous attempt ${incompleteReason} without reportStatus and may be incomplete. Inspect existing work, finish only the remaining work, avoid repeated side effects, and call reportStatus.`
     ] : attempt > 0 ? [
       "This run is a retry after a transient AI service error. Files, shell commands, or ingestion may already have been applied in this workspace \u2014 inspect what is already there and continue from it rather than repeating that work."
     ] : []
@@ -5415,11 +5458,11 @@ async function runAgentAttempt(req, attempt, retryReason) {
     toolChoice: "required",
     stopWhen: [
       hasToolCall("reportStatus"),
-      stepCountIs(profile.maxSteps)
+      stepCountIs(maxSteps)
     ],
     prepareStep: ({ stepNumber, messages }) => ({
       messages: withCachedHistory(messages),
-      ...stepNumber >= profile.maxSteps - 1 && {
+      ...stepNumber >= maxSteps - 1 && {
         activeTools: ["reportStatus"]
       }
     }),
@@ -5459,12 +5502,20 @@ async function runAgentAttempt(req, attempt, retryReason) {
   }
   const end = Date.now();
   const usage = await stream.totalUsage;
+  const steps = await stream.steps;
+  const stepCount = steps.length;
+  const hitStepLimit = stepCount >= maxSteps;
+  const lastStep = steps[steps.length - 1];
+  const finishReason = lastStep?.finishReason;
   trackAgentRun({
     operation: req.operation,
     profile: profileName,
     attempt: attempt + ATTEMPT_NUMBER_OFFSET,
     durationMs: end - start,
-    usage
+    usage,
+    stepCount,
+    hitStepLimit,
+    finishReason
   });
   logger.info(
     {
@@ -5473,7 +5524,11 @@ async function runAgentAttempt(req, attempt, retryReason) {
       operation: req.operation,
       profile: profileName,
       model: profile.model,
-      usage
+      usage,
+      stepCount,
+      maxSteps,
+      hitStepLimit,
+      finishReason
     },
     "runAgent finished"
   );
@@ -5488,27 +5543,25 @@ async function runAgentAttempt(req, attempt, retryReason) {
   const toolResults = await stream.toolResults;
   const report = [...toolResults].reverse().find((r) => r.toolName === "reportStatus");
   if (!report) {
-    const steps = await stream.steps;
-    const lastStep = steps[steps.length - 1];
     logger.error(
       {
-        finishReason: lastStep?.finishReason,
+        finishReason,
         rawFinishReason: lastStep?.rawFinishReason,
-        stepCount: steps.length,
+        stepCount,
         lastStepToolCalls: lastStep?.toolCalls?.map((c) => c.toolName)
       },
       "Agent finished without calling reportStatus"
     );
-    const incomplete = steps.length >= profile.maxSteps || lastStep?.finishReason !== "stop";
-    throw new MissingReportError(incomplete);
+    throw new MissingReportError(
+      incompleteCauseOf(stepCount, maxSteps, finishReason)
+    );
   }
   const result = report.output;
   if (result.status !== "success") {
-    const steps = await stream.steps;
     logger.warn(
       {
         reason: result.reason,
-        stepCount: steps.length,
+        stepCount,
         recentSteps: steps.slice(-RECENT_STEPS_LOGGED).map((s) => ({
           text: s.text?.slice(0, LOGGED_CHARS),
           toolCalls: s.toolCalls?.map((c) => c.toolName),
@@ -6285,6 +6338,7 @@ var validationOutputSchema = z29.object({
   unrelatedFailure: z29.string().optional()
 });
 var MAX_IMPLEMENT_VALIDATION_ATTEMPTS = 3;
+var INGESTION_MAX_STEPS = 96;
 var FIRST_IMPLEMENTATION_ATTEMPT = 1;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
 var INGEST_DIR = ".algolia-wizard";
@@ -6670,10 +6724,15 @@ function ingestOutcome(executions, repoRoot, ingestCommand) {
   const succeeded = newestFirst.filter(
     (e) => e.approved && e.exitCode === 0 && !e.timedOut
   );
+  const run2 = succeeded.find(matchesReportedCommand) ?? succeeded.find((e) => withCount.includes(e));
+  const runs = executions.filter(
+    (e) => e.approved && matchesReportedCommand(e)
+  ).length;
   return {
-    run: succeeded.find(matchesReportedCommand) ?? succeeded.find((e) => withCount.includes(e)),
+    run: run2,
     attempt: ingestCommand ? newestFirst.find(matchesReportedCommand) : void 0,
-    recordCount: parseIngestRecordCount(withCount[0]?.output ?? "")
+    recordCount: parseIngestRecordCount(withCount[0]?.output ?? ""),
+    attempts: run2 && !matchesReportedCommand(run2) ? runs + 1 : runs
   };
 }
 var INGEST_OUTPUT_TAIL_CHARS = 400;
@@ -7048,6 +7107,9 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
         tools: toolsForUseCase(currentUseCase, input.ingestionSource),
         outputSchema: implementationOutputSchema,
         modelProfile: isRetry ? "implementationRetry" /* implementationRetry */ : "implementation" /* implementation */,
+        ...currentUseCase === "ingestion" && {
+          maxSteps: INGESTION_MAX_STEPS
+        },
         toolContext
       });
     } catch (err) {
@@ -7181,7 +7243,8 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     const {
       run: ingestRun,
       attempt: ingestAttempt,
-      recordCount
+      recordCount,
+      attempts: ingestRunAttempts
     } = outcome;
     let ingestCwd = ".";
     if (ingestAttempt) {
@@ -7214,7 +7277,8 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
           record_count: ingestRecordCount,
           duration_ms: ingestDurationMs ?? 0,
           index_name: targetIndex,
-          record_schema: recordSchema(sample, confirmed2?.[0]?.attributes ?? [])
+          record_schema: recordSchema(sample, confirmed2?.[0]?.attributes ?? []),
+          attempts: ingestRunAttempts
         });
       } else {
         logger.warn(
@@ -7250,6 +7314,7 @@ ${detail}` : ""}`
         error_message: `ingestion did not complete: ${reason}`,
         error_type: "Ingest Records",
         product_area: "AI Wizard",
+        attempts: ingestRunAttempts,
         ...ingestAttempt?.exitCode != null ? { error_code: String(ingestAttempt.exitCode) } : {}
       });
     }
@@ -9794,7 +9859,7 @@ async function resetProjectState() {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.91.0",
+  version: "0.93.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.91.0",
+  "version": "0.93.0",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {