@alisio/sdk 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/index.d.ts

@@ -546,6 +546,17 @@ export interface RunTimeoutInfo {
      */
     attempts?: number;
 }
+/** What a `run_failed` event with `code: "output_truncated"` says about the limit that cut it. */
+export interface RunTruncationInfo {
+    /** How many responses were cut off (the first plus every recovery). */
+    attempts: number;
+    /** The output-token budget of the cut requests (the effective one, see `source`). */
+    maxOutputTokens: number;
+    /** Where that budget came from: the user, the model's catalog, or the default. */
+    source?: "user" | "model" | "default";
+    /** The model whose responses were cut. */
+    model?: string;
+}
 /**
  * Payload of each event type the core emits today, keyed by `RunEvent.type`. Additive: new
  * types and new optional fields may appear; existing fields keep their meaning.
@@ -627,9 +638,14 @@ export interface RunEventDataMap {
         text: string;
         truncated?: boolean;
     };
+    /**
+     * `maxOutputTokens` is the effective budget of the cut request; `source` says whether it was
+     * set by the user, taken from the model's catalog, or the default.
+     */
     response_truncated: {
         turn: number;
         maxOutputTokens: number;
+        source?: "user" | "model" | "default";
     };
     /**
      * A model request stayed completely silent for `limits.firstTokenTimeoutMs` and the same
@@ -643,19 +659,37 @@ export interface RunEventDataMap {
         reason: "first_token_timeout";
         afterMs: number;
     };
+    /**
+     * A model response was cut off by the output-token limit before it was usable (no text and no
+     * tool call, or a tool call whose arguments are incomplete) and the same turn is requested
+     * again with a short continuation notice. The truncated tool calls were discarded, never
+     * executed or persisted, and the retry is not a turn. `attempt` is the recovery about to start
+     * (1-based), `of` the recoveries allowed (`limits.truncationRecoveries`), `reason` what was
+     * lost, and `effort` the lowered reasoning effort of that request, when one was applied.
+     */
+    truncation_recovery: {
+        attempt: number;
+        of: number;
+        reason: "tool_call_cut" | "empty_response";
+        maxOutputTokens: number;
+        effort?: string;
+    };
     run_turns_exceeded: {
         turns: number;
         maxTurns: number;
     };
     /**
      * The run failed. `error` is always a human-readable message. `code: "timeout"` (with `timeout`)
-     * marks a run stopped by a time limit instead of a provider or tool error; both fields are
-     * additive and absent for every other failure.
+     * marks a run stopped by a time limit instead of a provider or tool error;
+     * `code: "output_truncated"` (with `truncation`) a run whose responses kept being cut off by
+     * the output-token limit after the allowed recoveries. These fields are additive and absent
+     * for every other failure.
      */
     run_failed: {
         error: string;
-        code?: "timeout";
+        code?: "timeout" | "output_truncated";
         timeout?: RunTimeoutInfo;
+        truncation?: RunTruncationInfo;
     };
     run_cancelled: {
         error: string;
@@ -1945,6 +1979,19 @@ export interface ApiError {
     correlationId: string;
 }
 export declare function definePlugin<T extends Plugin>(plugin: T): T;
+/** `OutputTruncatedError.code`: a provider's reply was cut off by the output-token limit. */
+export declare const OUTPUT_TRUNCATED_CODE = "output_truncated";
+/**
+ * A provider that cannot yield a usable `completed` message because the output-token limit cut
+ * the response before anything usable existed (no text and no complete tool call) throws this,
+ * so the host can recover instead of failing the run. Hosts match on `code` (not `instanceof`),
+ * because a plugin may bundle its own copy of this package. Prefer yielding `completed` with
+ * `truncated: true` whenever the partial message is representable.
+ */
+export declare class OutputTruncatedError extends Error {
+    readonly code = "output_truncated";
+    constructor(message?: string);
+}
 export declare const textResult: (text: string, isError?: boolean) => ToolResult;
 /**
  * Text-only view of a tool result: the content filtered to its text parts, order preserved.

package/dist/index.js

@@ -30,6 +30,22 @@ export function isEphemeralRunEventType(type) {
 export function definePlugin(plugin) {
     return plugin;
 }
+/** `OutputTruncatedError.code`: a provider's reply was cut off by the output-token limit. */
+export const OUTPUT_TRUNCATED_CODE = "output_truncated";
+/**
+ * A provider that cannot yield a usable `completed` message because the output-token limit cut
+ * the response before anything usable existed (no text and no complete tool call) throws this,
+ * so the host can recover instead of failing the run. Hosts match on `code` (not `instanceof`),
+ * because a plugin may bundle its own copy of this package. Prefer yielding `completed` with
+ * `truncated: true` whenever the partial message is representable.
+ */
+export class OutputTruncatedError extends Error {
+    code = OUTPUT_TRUNCATED_CODE;
+    constructor(message = "The response was cut off by the output-token limit.") {
+        super(message);
+        this.name = "OutputTruncatedError";
+    }
+}
 export const textResult = (text, isError = false) => ({
     content: [{ type: "text", text }],
     ...(isError ? { isError: true } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/sdk",
-  "version": "0.1.0-alpha.19",
+  "version": "0.1.0-alpha.20",
   "description": "Typed plugin SDK for Alisio: the stable contract for tools, commands, context, compaction and session hooks, model completions and storage. Types only plus tiny helpers; zero runtime dependencies.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",