@wardby/cli 0.8.0 → 0.9.0

package/dist/core/run-steps/writer.js

@@ -0,0 +1,279 @@
+/**
+ * The one writer of RunStep rows. Every source hands it batches (RunStepSink). Before anything is
+ * stored, each step's text is redacted by exact value against the secret values the loader covers:
+ * the agent's secrets (readable and brokered) and its attached MCP servers' secrets, the same source
+ * the transcript recorder uses; run capabilities are masked by token shape. The native-sandbox
+ * gateway capability is passed by the gateway as `extraSecretValues` and redacted the same way. A batch whose run's secret values
+ * can't be read writes nothing (fail closed). A step whose kind is unknown, whose callId is invalid or
+ * would change under redaction is dropped and not counted in stepsDropped; only steps past the cap are
+ * counted, once per callId. One run's batches are written in arrival order, within one process only
+ * (step/result ordering across processes is not guaranteed), under a row lock on the run, so seq has
+ * no gaps or duplicates whichever process writes. Known limits: a dropped step may be counted again
+ * after a process restart, after its run is evicted from the remembered set, past the per-run id
+ * limit, or when two processes write the same run. A result is matched only to a stored callId, which
+ * is already clean, so a result's callId is never persisted. At the detail level (the run's
+ * Run.runStepsLevel, fixed at dispatch), each step's detail text is redacted the same way
+ * (stepDetailer) before it is cut and stored; below it, detail material in a batch is dropped
+ * unread. Step text, input and output lose terminal control sequences and control characters
+ * (plainText: exact values masked on the raw text first, then stripControlSequences, then the full
+ * redaction), so no reader is sent an escape sequence. Log lines
+ * carry the run id, a fixed event code and an error's name: never text, never an error's message.
+ */
+import { createHash } from "node:crypto";
+import { REDACTED, redactSecrets } from "../../coding/redact.js";
+import { logger } from "../logger.js";
+import { loadAgentSecretValues } from "../secret-guard.js";
+import { MIN_REDACTABLE_SECRET_LENGTH } from "../secret-spans.js";
+import { loadRunStepRetentionDays, loadRunStepsLevel, recordedRunStepsLevel } from "./config.js";
+import { stripControlSequences } from "./control-chars.js";
+import { joinDetail, stepDetailer } from "./detail.js";
+import { stepSummarizer } from "./summarize.js";
+import { MAX_RUN_STEPS, MAX_STEP_DETAIL_CHARS, STEP_CALL_ID, STEP_STATUS, STEP_TOOL_NAME, tailOf, } from "./types.js";
+const stepsLog = logger.child({ module: "run-steps" });
+const DAY_MS = 24 * 60 * 60 * 1000;
+const TX = { maxWait: 5_000, timeout: 10_000 };
+/** How long flush() waits for queued writes at shutdown. */
+export const FLUSH_TIMEOUT_MS = 5_000;
+/** Over-cap callIds remembered (as 32-character hashes): at most this many per run and in all. */
+const DROPPED_PER_RUN = 10_000;
+const DROPPED_TOTAL = 200_000;
+const callKey = (callId) => createHash("sha256").update(callId).digest("hex").slice(0, 32);
+function uniqueByCallId(steps) {
+    const seen = new Set();
+    return steps.filter((step) => {
+        if (!STEP_CALL_ID.test(step.callId) || seen.has(step.callId))
+            return false;
+        seen.add(step.callId);
+        return true;
+    });
+}
+/** A private-use character: stands in for a masked value while control sequences are stripped. */
+const HELD = "\uE000";
+/**
+ * Untrusted text as plain text, safely: every secret value is masked on the raw text first, whole
+ * and partial (StepDetailer.premask: the text's edges and every line and ellipsis boundary), then
+ * control sequences are stripped (stripControlSequences), and only then does the full redaction
+ * run. Stripping first could take a secret's first character as a malformed sequence's final byte
+ * (`ESC Z` + value) and leave the rest of it matching nothing; the full redaction after the strip
+ * still masks a value that only the strip joined (one split by colour codes). The mask is a
+ * placeholder no sequence pattern can take as a byte of its own (a sequence before `[REDACTED]`
+ * would eat its "["), swapped for the marker after the strip.
+ */
+function plainText(raw, premask, headWasCut = false) {
+    if (!premask)
+        return stripControlSequences(raw);
+    const held = premask(raw.replaceAll(HELD, ""), headWasCut, HELD);
+    return stripControlSequences(held).replaceAll(HELD, REDACTED);
+}
+/**
+ * A result's detail suffix: its end taken from the raw output first (tailOf), so the premask's head
+ * check runs at the cut the detailer will see, then plainText, then the detailer.
+ */
+function plainOutput(raw, outputCut, premask, detailer) {
+    const source = tailOf(raw);
+    const cut = outputCut || source.cut;
+    return detailer.output({ output: plainText(source.text, premask, cut), outputCut: cut });
+}
+/** `step` without its detail-only input. */
+function withoutInput(step) {
+    if (step.kind !== "tool" || step.input === undefined)
+        return step;
+    const { input: _input, inputTruncated: _inputTruncated, ...rest } = step;
+    return rest;
+}
+/** A step's text and input as plainText. */
+function plainStep(step, premask) {
+    if (step.kind === "said")
+        return { ...step, text: plainText(step.text, premask) };
+    const input = step.input === undefined ? {} : { input: plainText(step.input, premask) };
+    return { ...step, text: plainText(step.text, premask), ...input };
+}
+function safeToolName(tool, secretValues) {
+    const shown = redactSecrets(tool, secretValues);
+    return STEP_TOOL_NAME.test(shown) ? shown : "tool";
+}
+export class RunStepWriter {
+    deps;
+    queues = new Map();
+    /**
+     * Hashes of the callIds already counted in stepsDropped, so history resent past the cap is not
+     * counted again. Least recently used run first; bounded in total, whatever the ids' length.
+     */
+    droppedIds = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    record(runId, batch, extraSecretValues = []) {
+        if (this.deps.level === "off")
+            return Promise.resolve();
+        if (batch.steps.length === 0 && batch.results.length === 0)
+            return Promise.resolve();
+        const previous = this.queues.get(runId) ?? Promise.resolve();
+        const next = previous
+            .then(() => this.write(runId, batch, extraSecretValues))
+            .catch((err) => {
+            (this.deps.log ?? stepsLog).warn({ runId, event: "run_steps_write_failed", errorName: err instanceof Error ? err.name : typeof err }, "could not record a run's steps; they were dropped");
+        });
+        this.queues.set(runId, next);
+        void next.then(() => {
+            if (this.queues.get(runId) === next)
+                this.queues.delete(runId);
+        });
+        return next;
+    }
+    /**
+     * Resolves when every write queued so far has settled, or after `timeoutMs`: called before the
+     * process disconnects from the database, so a run's last steps are not cut off. Never rejects.
+     */
+    async flush(timeoutMs = FLUSH_TIMEOUT_MS) {
+        const pending = [...this.queues.values()];
+        if (pending.length === 0)
+            return;
+        let timer;
+        const bound = new Promise((resolve) => {
+            timer = setTimeout(resolve, timeoutMs);
+        });
+        try {
+            await Promise.race([Promise.allSettled(pending), bound]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    now() {
+        return (this.deps.now ?? (() => new Date()))();
+    }
+    async write(runId, batch, extraSecretValues) {
+        const { db } = this.deps;
+        const run = await db.run.findUnique({ where: { id: runId }, select: { agentId: true, runStepsLevel: true } });
+        if (!run)
+            return;
+        const level = recordedRunStepsLevel(run.runStepsLevel, this.deps.level);
+        if (level === "off")
+            return;
+        const detailed = level === "detail";
+        // Below detail a tool's input is never stored, so it is dropped here, before any redaction.
+        const extracted = uniqueByCallId(batch.steps.filter((step) => step.kind === "tool" || step.kind === "said")).map((step) => (detailed ? step : withoutInput(step)));
+        const results = batch.results.filter((r) => STEP_CALL_ID.test(r.callId) && STEP_STATUS.test(r.status));
+        const outputs = detailed && results.some((r) => typeof r.output === "string");
+        // Read fresh for every batch that stores text (steps, or outputs at detail), never cached: a
+        // rotated or newly attached secret must be covered. Rejects (and the batch is dropped) when the
+        // values can't be read: never an unredacted write.
+        const needsValues = extracted.length > 0 || outputs;
+        const own = needsValues ? await this.deps.secretValues(run.agentId) : [];
+        const extras = needsValues ? extraSecretValues.filter(Boolean) : [];
+        const rawValues = [...own, ...extras];
+        // Each value also as plain text, as the step text is: a value holding a control character
+        // (never a stripped form too short to redact safely).
+        const values = [
+            ...new Set(rawValues.flatMap((value) => {
+                const plain = stripControlSequences(value);
+                return plain.length >= MIN_REDACTABLE_SECRET_LENGTH ? [value, plain] : [value];
+            })),
+        ];
+        // The summary forms are built once per batch, on the first row; the detailer (whose premask
+        // every text goes through first) once per batch that has any secret value.
+        let summarize;
+        let detailer;
+        const detailOf = () => (detailer ??= stepDetailer(values));
+        const premask = values.length > 0 ? (raw, headWasCut, marker) => detailOf().premask(raw, headWasCut, marker) : undefined;
+        const steps = extracted.map((step) => plainStep(step, premask));
+        const at = this.now();
+        const expiresAt = new Date(at.getTime() + this.deps.retentionDays * DAY_MS);
+        // callId is stored as text: a step whose callId holds a secret value is not stored at all.
+        const clean = steps.filter((step) => redactSecrets(step.callId, values) === step.callId);
+        const rows = clean.map((step) => ({
+            kind: step.kind,
+            tool: step.kind === "tool" ? safeToolName(step.tool, values) : null,
+            callId: step.callId,
+            summary: (summarize ??= stepSummarizer(values))(step),
+            detail: detailed ? detailOf().step(step).slice(0, MAX_STEP_DETAIL_CHARS) : null,
+            at,
+            expiresAt,
+        }));
+        const maxSteps = this.deps.maxSteps ?? MAX_RUN_STEPS;
+        const counted = this.droppedIds.get(runId) ?? new Set();
+        if (this.droppedIds.has(runId)) {
+            this.droppedIds.delete(runId);
+            this.droppedIds.set(runId, counted);
+        }
+        // Each result's detail suffix, computed before the transaction: redaction is CPU work, and the
+        // transaction holds the run's row lock.
+        const suffixes = results.map((result) => outputs && typeof result.output === "string"
+            ? plainOutput(result.output, result.outputCut === true, premask, detailOf())
+            : undefined);
+        const newlyDropped = [];
+        await db.$transaction(async (tx) => {
+            await tx.$queryRaw `SELECT 1 FROM "Run" WHERE "id" = ${runId} FOR UPDATE`;
+            if (rows.length > 0) {
+                const existing = await tx.runStep.findMany({
+                    where: { runId, callId: { in: rows.map((row) => row.callId) } },
+                    select: { callId: true },
+                });
+                const known = new Set(existing.map((row) => row.callId));
+                const fresh = rows.filter((row) => !known.has(row.callId));
+                const last = await tx.runStep.findFirst({ where: { runId }, orderBy: { seq: "desc" }, select: { seq: true } });
+                const start = last?.seq ?? 0;
+                const kept = fresh.slice(0, Math.max(0, maxSteps - start));
+                if (kept.length > 0) {
+                    await tx.runStep.createMany({ data: kept.map((row, index) => ({ ...row, runId, seq: start + index + 1 })) });
+                }
+                const over = fresh.slice(kept.length).filter((row) => !counted.has(callKey(row.callId)));
+                newlyDropped.push(...over.map((row) => row.callId));
+                const dropped = over.length;
+                if (dropped > 0)
+                    await tx.run.update({ where: { id: runId }, data: { stepsDropped: { increment: dropped } } });
+            }
+            for (const [index, result] of results.entries()) {
+                const suffix = suffixes[index];
+                if (suffix === undefined) {
+                    // The first status wins: a result resent with the history, or replayed, changes nothing.
+                    await tx.runStep.updateMany({
+                        where: { runId, callId: result.callId, kind: "tool", status: null },
+                        data: { status: result.status },
+                    });
+                    continue;
+                }
+                const open = await tx.runStep.findFirst({
+                    where: { runId, callId: result.callId, kind: "tool", status: null },
+                    select: { id: true, detail: true },
+                });
+                if (!open)
+                    continue;
+                await tx.runStep.update({
+                    where: { id: open.id },
+                    data: { status: result.status, detail: joinDetail(open.detail, suffix) },
+                });
+            }
+        }, TX);
+        if (newlyDropped.length > 0)
+            this.rememberDropped(runId, counted, newlyDropped);
+    }
+    rememberDropped(runId, counted, ids) {
+        const limits = this.deps.droppedLimits ?? { perRun: DROPPED_PER_RUN, total: DROPPED_TOTAL };
+        for (const id of ids)
+            if (counted.size < limits.perRun)
+                counted.add(callKey(id));
+        this.droppedIds.delete(runId);
+        this.droppedIds.set(runId, counted);
+        while (this.rememberedDroppedCount() > limits.total && this.droppedIds.size > 1) {
+            this.droppedIds.delete(this.droppedIds.keys().next().value);
+        }
+    }
+    /** How many dropped callIds are remembered in all (tests). */
+    rememberedDroppedCount() {
+        let total = 0;
+        for (const set of this.droppedIds.values())
+            total += set.size;
+        return total;
+    }
+}
+/** The process's writer: settings from the environment (an invalid value throws, naming it). */
+export function buildRunStepWriter(db, cipher, env = process.env) {
+    return new RunStepWriter({
+        db,
+        level: loadRunStepsLevel(env),
+        retentionDays: loadRunStepRetentionDays(env),
+        secretValues: async (agentId) => (await loadAgentSecretValues(db, cipher, agentId)).flatMap((entry) => entry.values),
+    });
+}

package/dist/core/runner.d.ts

@@ -21,6 +21,7 @@ import { Prisma, type PrismaClient, type Run, type RunTrigger } from "#prisma";
 import type { ProviderRegistry } from "../providers/index.js";
 import type { EngineProgress, EngineResult, LoadedTool } from "../providers/engine/types.js";
 import { RunOwnershipLostError, type StepRunner } from "../providers/engine/types.js";
+import type { RunStepSink } from "./run-steps/types.js";
 import { type PrivilegedHost } from "../sandbox/host-functions.js";
 import type { safeFetch } from "../sandbox/safe-fetch.js";
 import { type RunDrivability, type WorkerLauncher } from "../native-worker/gateway.js";
@@ -96,6 +97,7 @@ declare const DELEGATION_CHILD_SELECT: {
     readonly budgetUsd: true;
     readonly ownerId: true;
     readonly nativeExecutionMode: true;
+    readonly runSteps: true;
     readonly codingProfile: {
         readonly select: {
             readonly allowWebhookTaskOverride: true;
@@ -148,6 +150,8 @@ export type NativeRunProviders = Pick<ProviderRegistry, "llm" | "engine" | "data
     nativeSandbox?: WorkerLauncher;
     /** Overrides the sandbox's outbound network call — tests only. */
     sandboxFetch?: typeof safeFetch;
+    /** Records runs' steps (src/core/run-steps/writer.ts); absent = no steps are recorded. */
+    runSteps?: RunStepSink;
 };
 /**
  * Raised when a run's step boundary observed a cancellation (DbosExecutor's

package/dist/core/runner.js

@@ -23,6 +23,7 @@ import { RunOwnershipLostError, STEPS_CHANGED_REASON, StepReplayMismatchError, r
 import { isLlmEffort } from "../providers/llm/types.js";
 import { CODING_REPOSITORY_LINK_FILTER, extraCodingRepositoryLinks, hasCodingRepositoryList, RepositoryChoiceRefusedError, resolveCodingRepository, } from "./coding-repository.js";
 import { delegationLimitRefusal, delegationSlot, priorDelegationSlots } from "./delegation-slots.js";
+import { runStepsHook } from "./run-steps/native.js";
 import { createPrivilegedHost } from "../sandbox/host-functions.js";
 import { consoleRedactionValues } from "../sandbox/secret-broker.js";
 import { runUserToolCall } from "../sandbox/user-tool.js";
@@ -73,6 +74,7 @@ import { pinNativeRunPricing } from "./run-pricing.js";
 import { RoutingLlmProvider } from "../providers/llm/routing.js";
 import { ModelUnavailableError } from "../providers/llm/catalog-types.js";
 import { trackRun } from "./in-flight-runs.js";
+import { dispatchRunStepsLevel } from "./run-steps/config.js";
 import { ReviewReadLedger } from "./review-reads.js";
 import { createRepoAccessGate, requiredLevel } from "./repo-access.js";
 import { loadBudgetEvent, ownerBudgetSentence } from "./budget-events.js";
@@ -216,6 +218,7 @@ const DELEGATION_CHILD_SELECT = {
     budgetUsd: true,
     ownerId: true,
     nativeExecutionMode: true,
+    runSteps: true,
     codingProfile: { select: { allowWebhookTaskOverride: true, timeoutSec: true, repository: true, baseRef: true } },
 };
 /**
@@ -566,7 +569,14 @@ export async function createRun(db, agentName, trigger = "manual") {
     if (agent.nativeExecutionMode === "sandbox") {
         throw new Error(NATIVE_SANDBOX_NOT_CONFIGURED);
     }
-    return db.run.create({ data: { agentId: agent.id, trigger, nativeExecutionMode: agent.nativeExecutionMode } });
+    return db.run.create({
+        data: {
+            agentId: agent.id,
+            trigger,
+            nativeExecutionMode: agent.nativeExecutionMode,
+            runStepsLevel: dispatchRunStepsLevel(agent),
+        },
+    });
 }
 /**
  * The trusted load of a native run: the agent, its attached tools and their
@@ -1326,6 +1336,7 @@ export function createNativeRunTools(options) {
                                 taskOverride,
                                 triggeredById: existingRun.triggeredById,
                                 nativeExecutionMode: childAgent.nativeExecutionMode,
+                                runStepsLevel: dispatchRunStepsLevel(childAgent),
                             },
                         });
                     }
@@ -2087,6 +2098,7 @@ async function executeTrackedRun(runId, providers, db, onText, step) {
         });
         const { runSandboxTool } = tools;
         const onProgress = (progress) => recordNativeRunProgress(db, runId, progress);
+        const onTurn = runStepsHook(providers.runSteps, runId);
         const llm = loaded.pricing && providers.llm instanceof RoutingLlmProvider
             ? providers.llm.forRun(loaded.pricing.entry)
             : providers.llm;
@@ -2102,6 +2114,7 @@ async function executeTrackedRun(runId, providers, db, onText, step) {
                 mcpSecretValues: tools.mcpSecretValues,
                 drivability: () => runDrivability(db, runId),
                 launcher: providers.nativeSandbox,
+                ...(providers.runSteps ? { runSteps: providers.runSteps } : {}),
             });
             return await finishNativeRun(finishContext, loaded.agent.model, engineResult);
         }
@@ -2116,6 +2129,7 @@ async function executeTrackedRun(runId, providers, db, onText, step) {
                 : {}),
             onText,
             onProgress,
+            ...(onTurn ? { onTurn } : {}),
             step,
         });
         return await finishNativeRun(finishContext, loaded.agent.model, engineResult);

package/dist/generated/prisma/browser.d.ts

@@ -117,6 +117,14 @@ export type CodingRun = Prisma.CodingRunModel;
  * the blob store under blobKey; the unredacted transcript is never stored.
  */
 export type RunTranscript = Prisma.RunTranscriptModel;
+/**
+ * Model RunStep
+ * One line of what a run did: a tool call (with its status once the result is back) or what the
+ * model said. Derived by trusted code from model traffic and written only by the control plane's
+ * RunStepWriter, after exact-value redaction against the run's secret values
+ * (docs/debugging-agent-runs.md#run-steps). Never tool output at the summary level.
+ */
+export type RunStep = Prisma.RunStepModel;
 /**
  * Model CodingService
  * Coding-run services (docs/coding-services.md): the catalog a repository's

package/dist/generated/prisma/client.d.ts

@@ -136,6 +136,14 @@ export type CodingRun = Prisma.CodingRunModel;
  * the blob store under blobKey; the unredacted transcript is never stored.
  */
 export type RunTranscript = Prisma.RunTranscriptModel;
+/**
+ * Model RunStep
+ * One line of what a run did: a tool call (with its status once the result is back) or what the
+ * model said. Derived by trusted code from model traffic and written only by the control plane's
+ * RunStepWriter, after exact-value redaction against the run's secret values
+ * (docs/debugging-agent-runs.md#run-steps). Never tool output at the summary level.
+ */
+export type RunStep = Prisma.RunStepModel;
 /**
  * Model CodingService
  * Coding-run services (docs/coding-services.md): the catalog a repository's

package/dist/generated/prisma/commonInputTypes.d.ts

@@ -85,6 +85,12 @@ export type EnumNativeExecutionModeFilter<$PrismaModel = never> = {
     notIn?: $Enums.NativeExecutionMode[] | Prisma.ListEnumNativeExecutionModeFieldRefInput<$PrismaModel>;
     not?: Prisma.NestedEnumNativeExecutionModeFilter<$PrismaModel> | $Enums.NativeExecutionMode;
 };
+export type EnumRunStepsLevelNullableFilter<$PrismaModel = never> = {
+    equals?: $Enums.RunStepsLevel | Prisma.EnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    in?: $Enums.RunStepsLevel[] | Prisma.ListEnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    notIn?: $Enums.RunStepsLevel[] | Prisma.ListEnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    not?: Prisma.NestedEnumRunStepsLevelNullableFilter<$PrismaModel> | $Enums.RunStepsLevel | null;
+};
 export type SortOrderInput = {
     sort: Prisma.SortOrder;
     nulls?: Prisma.NullsOrder;
@@ -204,6 +210,15 @@ export type EnumNativeExecutionModeWithAggregatesFilter<$PrismaModel = never> =
     _min?: Prisma.NestedEnumNativeExecutionModeFilter<$PrismaModel>;
     _max?: Prisma.NestedEnumNativeExecutionModeFilter<$PrismaModel>;
 };
+export type EnumRunStepsLevelNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.RunStepsLevel | Prisma.EnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    in?: $Enums.RunStepsLevel[] | Prisma.ListEnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    notIn?: $Enums.RunStepsLevel[] | Prisma.ListEnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    not?: Prisma.NestedEnumRunStepsLevelNullableWithAggregatesFilter<$PrismaModel> | $Enums.RunStepsLevel | null;
+    _count?: Prisma.NestedIntNullableFilter<$PrismaModel>;
+    _min?: Prisma.NestedEnumRunStepsLevelNullableFilter<$PrismaModel>;
+    _max?: Prisma.NestedEnumRunStepsLevelNullableFilter<$PrismaModel>;
+};
 export type DecimalNullableFilter<$PrismaModel = never> = {
     equals?: runtime.Decimal | runtime.DecimalJsLike | number | string | Prisma.DecimalFieldRefInput<$PrismaModel> | null;
     in?: runtime.Decimal[] | runtime.DecimalJsLike[] | number[] | string[] | Prisma.ListDecimalFieldRefInput<$PrismaModel> | null;
@@ -721,6 +736,12 @@ export type NestedEnumNativeExecutionModeFilter<$PrismaModel = never> = {
     notIn?: $Enums.NativeExecutionMode[] | Prisma.ListEnumNativeExecutionModeFieldRefInput<$PrismaModel>;
     not?: Prisma.NestedEnumNativeExecutionModeFilter<$PrismaModel> | $Enums.NativeExecutionMode;
 };
+export type NestedEnumRunStepsLevelNullableFilter<$PrismaModel = never> = {
+    equals?: $Enums.RunStepsLevel | Prisma.EnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    in?: $Enums.RunStepsLevel[] | Prisma.ListEnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    notIn?: $Enums.RunStepsLevel[] | Prisma.ListEnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    not?: Prisma.NestedEnumRunStepsLevelNullableFilter<$PrismaModel> | $Enums.RunStepsLevel | null;
+};
 export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
     equals?: string | Prisma.StringFieldRefInput<$PrismaModel>;
     in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>;
@@ -854,6 +875,15 @@ export type NestedEnumNativeExecutionModeWithAggregatesFilter<$PrismaModel = nev
     _min?: Prisma.NestedEnumNativeExecutionModeFilter<$PrismaModel>;
     _max?: Prisma.NestedEnumNativeExecutionModeFilter<$PrismaModel>;
 };
+export type NestedEnumRunStepsLevelNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.RunStepsLevel | Prisma.EnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    in?: $Enums.RunStepsLevel[] | Prisma.ListEnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    notIn?: $Enums.RunStepsLevel[] | Prisma.ListEnumRunStepsLevelFieldRefInput<$PrismaModel> | null;
+    not?: Prisma.NestedEnumRunStepsLevelNullableWithAggregatesFilter<$PrismaModel> | $Enums.RunStepsLevel | null;
+    _count?: Prisma.NestedIntNullableFilter<$PrismaModel>;
+    _min?: Prisma.NestedEnumRunStepsLevelNullableFilter<$PrismaModel>;
+    _max?: Prisma.NestedEnumRunStepsLevelNullableFilter<$PrismaModel>;
+};
 export type NestedDecimalNullableFilter<$PrismaModel = never> = {
     equals?: runtime.Decimal | runtime.DecimalJsLike | number | string | Prisma.DecimalFieldRefInput<$PrismaModel> | null;
     in?: runtime.Decimal[] | runtime.DecimalJsLike[] | number[] | string[] | Prisma.ListDecimalFieldRefInput<$PrismaModel> | null;

package/dist/generated/prisma/enums.d.ts

@@ -3,6 +3,12 @@ export declare const AgentKind: {
     readonly coding: "coding";
 };
 export type AgentKind = (typeof AgentKind)[keyof typeof AgentKind];
+export declare const RunStepsLevel: {
+    readonly off: "off";
+    readonly summary: "summary";
+    readonly detail: "detail";
+};
+export type RunStepsLevel = (typeof RunStepsLevel)[keyof typeof RunStepsLevel];
 export declare const NativeExecutionMode: {
     readonly control_plane: "control_plane";
     readonly sandbox: "sandbox";

package/dist/generated/prisma/enums.js

@@ -11,6 +11,11 @@ export const AgentKind = {
     native: 'native',
     coding: 'coding'
 };
+export const RunStepsLevel = {
+    off: 'off',
+    summary: 'summary',
+    detail: 'detail'
+};
 export const NativeExecutionMode = {
     control_plane: 'control_plane',
     sandbox: 'sandbox'

package/dist/generated/prisma/internal/class.d.ts

@@ -260,6 +260,17 @@ export interface PrismaClient<in LogOpts extends Prisma.LogLevel = never, in out
     get runTranscript(): Prisma.RunTranscriptDelegate<ExtArgs, {
         omit: OmitOpts;
     }>;
+    /**
+     * `prisma.runStep`: Exposes CRUD operations for the **RunStep** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RunSteps
+      * const runSteps = await prisma.runStep.findMany()
+      * ```
+      */
+    get runStep(): Prisma.RunStepDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
     /**
      * `prisma.codingService`: Exposes CRUD operations for the **CodingService** model.
       * Example usage: