@prestyj/agent 5.29.0 → 5.30.0

package/dist/index.d.cts

@@ -80,6 +80,11 @@ declare function buildStreamRuleReminder(rules: readonly StreamRule[]): Message;
 interface StructuredToolResult {
     content: ToolResultContent;
     details?: unknown;
+    /** End the run after persisting this result, without another model call or
+     * draining steering/follow-ups. Use a sequential tool to also prevent later
+     * calls in the same batch from running (e.g. a pending plan-review handoff).
+     * Host control metadata only: never serialized into provider tool results. */
+    endRun?: boolean;
 }
 type ToolExecuteResult = string | StructuredToolResult;
 interface ToolContext {
@@ -359,6 +364,10 @@ interface AgentOptions {
     defaultHeaders?: StreamOptions["defaultHeaders"];
     /** OpenAI service tier for latency-sensitive first-party API requests. */
     serviceTier?: StreamOptions["serviceTier"];
+    /** Codex Responses-Lite request shape override (see StreamOptions). */
+    responsesLite?: StreamOptions["responsesLite"];
+    /** Codex strict tool schema override (see StreamOptions). */
+    strictTools?: StreamOptions["strictTools"];
     /** Whether the target model supports image input. When false, image blocks
      *  in messages/tool_results are downgraded to text placeholders. Default: true. */
     supportsImages?: boolean;

package/dist/index.d.ts

@@ -80,6 +80,11 @@ declare function buildStreamRuleReminder(rules: readonly StreamRule[]): Message;
 interface StructuredToolResult {
     content: ToolResultContent;
     details?: unknown;
+    /** End the run after persisting this result, without another model call or
+     * draining steering/follow-ups. Use a sequential tool to also prevent later
+     * calls in the same batch from running (e.g. a pending plan-review handoff).
+     * Host control metadata only: never serialized into provider tool results. */
+    endRun?: boolean;
 }
 type ToolExecuteResult = string | StructuredToolResult;
 interface ToolContext {
@@ -359,6 +364,10 @@ interface AgentOptions {
     defaultHeaders?: StreamOptions["defaultHeaders"];
     /** OpenAI service tier for latency-sensitive first-party API requests. */
     serviceTier?: StreamOptions["serviceTier"];
+    /** Codex Responses-Lite request shape override (see StreamOptions). */
+    responsesLite?: StreamOptions["responsesLite"];
+    /** Codex strict tool schema override (see StreamOptions). */
+    strictTools?: StreamOptions["strictTools"];
     /** Whether the target model supports image input. When false, image blocks
      *  in messages/tool_results are downgraded to text placeholders. Default: true. */
     supportsImages?: boolean;

package/dist/index.js

@@ -871,6 +871,8 @@ async function* agentLoop(messages, options) {
           onContextPrepared: options.onContextPrepared,
           promptCacheKey: options.promptCacheKey,
           serviceTier: options.serviceTier,
+          responsesLite: options.responsesLite,
+          strictTools: options.strictTools,
           supportsImages: options.supportsImages,
           supportsVideo: options.supportsVideo,
           compaction: options.compaction,
@@ -1582,6 +1584,7 @@ async function* agentLoop(messages, options) {
       }
       messages.push({ role: "tool", content: executionResult.toolResults });
       yield { type: "checkpoint", turn };
+      if (executionResult.endRun) break;
       const toolsAborted = executionResult.aborted;
       if (fatalToolArgumentError) {
         if (fatalToolArgumentRecoverable && !toolArgumentAutoContinueUsed) {
@@ -1718,6 +1721,7 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
   let resultContent;
   let details;
   let isError = false;
+  let endRun = false;
   let invalidArgAttempt;
   const tool = options.toolMap.get(toolCall.name);
   if (tool) {
@@ -1776,6 +1780,7 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
         hardSignals.length === 1 ? toolTimeout : AbortSignal.any(hardSignals)
       );
       const normalized = normalizeToolResult(raw);
+      endRun = normalized.endRun === true;
       resultContent = redactValue(normalized.content, toolRedactionOptions());
       details = redactValue(normalized.details, toolRedactionOptions());
       if (options.transformToolResult) {
@@ -1847,11 +1852,12 @@ ${hints}` : "") + "\nRe-issue the call with each field as the correct type.";
     durationMs,
     ...invalidArgAttempt === void 0 ? {} : { invalidArgAttempt }
   });
-  return { toolCallId: toolCall.id, content: resultContent, isError };
+  return { toolCallId: toolCall.id, content: resultContent, isError, endRun: endRun && !isError };
 }
 function createPreemptTracker(options, eventStream, state, resultsById, dispatchedIds) {
   const running = /* @__PURE__ */ new Map();
   let graceTimer;
+  let endRun = false;
   const preemptSignal = options.preemptSignal;
   const abandon = () => {
     graceTimer = void 0;
@@ -1875,7 +1881,7 @@ function createPreemptTracker(options, eventStream, state, resultsById, dispatch
   preemptSignal?.addEventListener("abort", onPreempt, { once: true });
   return {
     async run(toolCall) {
-      if (options.preemptSignal?.aborted) return;
+      if (endRun || options.preemptSignal?.aborted) return;
       dispatchedIds.add(toolCall.id);
       const interruptible = isInterruptibleTool(options.toolMap.get(toolCall.name), toolCall.name);
       running.set(toolCall.id, { toolCall, interruptible, startedAt: Date.now() });
@@ -1887,15 +1893,15 @@ function createPreemptTracker(options, eventStream, state, resultsById, dispatch
       running.delete(toolCall.id);
       if (resultsById.has(toolCall.id)) return;
       const alreadyMarked = typeof record.content === "string" ? record.content.startsWith(STEER_INTERRUPTED_TEXT) : record.content[0]?.type === "text" && record.content[0].text.startsWith(STEER_INTERRUPTED_TEXT);
-      resultsById.set(
-        toolCall.id,
-        interruptible && preemptSignal?.aborted && !alreadyMarked ? markSteerInterrupted(record) : record
-      );
+      const result = interruptible && preemptSignal?.aborted && !alreadyMarked ? markSteerInterrupted(record) : record;
+      resultsById.set(toolCall.id, result);
+      if (result.endRun && !result.isError) endRun = true;
       if (preemptSignal?.aborted && graceTimer === void 0 && running.size === 0) {
         eventStream.close();
       }
     },
     preempted: () => preemptSignal?.aborted === true,
+    endRun: () => endRun,
     dispose: () => {
       if (graceTimer !== void 0) clearTimeout(graceTimer);
       preemptSignal?.removeEventListener("abort", onPreempt);
@@ -1930,7 +1936,7 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
   void (async () => {
     try {
       for (const phase of phases) {
-        if (options.signal?.aborted || options.preemptSignal?.aborted) break;
+        if (options.signal?.aborted || options.preemptSignal?.aborted || tracker.endRun()) break;
         if (phase.sequential) {
           const signature = JSON.stringify([
             phase.sequential.name,
@@ -1968,7 +1974,12 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
   const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById, dispatchedIds);
   capToolResults(toolResults, options.maxToolResultChars);
   capTurnToolResults(toolResults, options.maxTurnToolResultChars);
-  return { toolResults, aborted, preempted: !aborted && tracker.preempted() };
+  return {
+    toolResults,
+    aborted,
+    preempted: !aborted && tracker.preempted(),
+    endRun: tracker.endRun()
+  };
 }
 async function* executeToolCallsParallel(toolCalls, initialToolResults, options) {
   const eventStream = new EventStream();
@@ -2002,7 +2013,12 @@ async function* executeToolCallsParallel(toolCalls, initialToolResults, options)
   const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById, dispatchedIds);
   capToolResults(toolResults, options.maxToolResultChars);
   capTurnToolResults(toolResults, options.maxTurnToolResultChars);
-  return { toolResults, aborted, preempted: !aborted && tracker.preempted() };
+  return {
+    toolResults,
+    aborted,
+    preempted: !aborted && tracker.preempted(),
+    endRun: tracker.endRun()
+  };
 }
 function cancelledBeforeStartText(name) {
   return `\`${name}\` was cancelled before it started, so it had no effect. Safe to retry.`;