@runtypelabs/sdk 9.2.1 → 9.3.1

package/dist/index.mjs

@@ -180,10 +180,7 @@ function createFlowEventTranslator() {
             pageOrigin: data.pageOrigin
           })
         ];
-      // Channels/markers/tool-family/approval/skip/source/state/custom/ping the
-      // flow consumer never read → no callback event. (A non-terminal `error` is
-      // only produced on agent streams; dropping it here avoids a false
-      // flow_error.)
+      // WHY(docs/why/packages/client/src.md#default-case-drops-events-the-flow-consumer-neve): Default case drops events the flow consumer never reads; a non-terminal error is agent-only, dropped here.
       default:
         return [];
     }
@@ -355,9 +352,7 @@ function createAgentEventTranslator() {
             toolName: data.toolName,
             success: data.success,
             result: data.result,
-            // A failure's reason travels on the frame's `error` field — the
-            // only carrier for complete-only failures like the MCP discovery
-            // connection pseudo-tool, which no longer emits an `error` frame.
+            // WHY(docs/why/packages/client/src.md#a-failures-reason-travels-on-error-the-only-carr): A failure's reason travels on `error`, the only carrier for complete-only MCP discovery failures.
             error: str(data.error),
             executionTime: data.executionTime
           })
@@ -494,10 +489,7 @@ function createAgentEventTranslator() {
         ];
       case "ping":
         return [compact({ type: "agent_ping", executionId, seq, timestamp: data.timestamp })];
-      // turn/text/reasoning open+close markers, step_*, artifact_*, source,
-      // state_snapshot/state_delta (agent-state channel with no stable SDK
-      // callback), custom (fallback beat / routing), and the skill-fold result
-      // envelope the SDK never consumed → no callback event.
+      // WHY(docs/why/packages/client/src.md#default-case-lists-every-channel-type-the-sdk-ca): Default case lists every channel type the SDK callback surface never consumed, so it maps to nothing.
       default:
         return [];
     }
@@ -1052,9 +1044,6 @@ var FlowBuilder = class {
     );
     return this;
   }
-  // ============================================================================
-  // Step Methods
-  // ============================================================================
   /**
    * Add a prompt step
    */
@@ -1553,9 +1542,6 @@ var FlowBuilder = class {
   memorySummary(config) {
     return this.addRawStep("memory-summary", config);
   }
-  // ============================================================================
-  // Subagent Helpers
-  // ============================================================================
   /**
    * Attach a subagent runtime tool to the most recent prompt step.
    *
@@ -1650,9 +1636,6 @@ var FlowBuilder = class {
     lastStep.config.tools = { ...existingTools, subagentConfig: opts };
     return this;
   }
-  // ============================================================================
-  // Build Method
-  // ============================================================================
   /**
    * Build the final dispatch request configuration
    */
@@ -1743,9 +1726,6 @@ var FlowBuilder = class {
     if (lastStep) lastStep.when = expression;
     return this;
   }
-  // ============================================================================
-  // Private Helpers
-  // ============================================================================
   addRawStep(type, config) {
     const { name, enabled, when, ...stepConfig } = config;
     this.addStep(type, name, stepConfig, enabled, when);
@@ -1949,7 +1929,6 @@ var CHECK_GRADER_KINDS = /* @__PURE__ */ new Set([
   "length",
   "latency",
   "no_error",
-  // Trace checks.
   "called_tool",
   "not_called_tool",
   "used_no_tools",
@@ -2233,7 +2212,8 @@ function normalizeCaseInput(input, where) {
       const mock = { toolName: m.toolName, output: m.output };
       if (m.input !== void 0) mock.input = m.input;
       if (typeof m.isError === "boolean") mock.isError = m.isError;
-      if (typeof m.sourceToolExecutionId === "string") mock.sourceToolExecutionId = m.sourceToolExecutionId;
+      if (typeof m.sourceToolExecutionId === "string")
+        mock.sourceToolExecutionId = m.sourceToolExecutionId;
       if (typeof m.truncated === "boolean") mock.truncated = m.truncated;
       return mock;
     });
@@ -2338,7 +2318,7 @@ async function computeEvalContentHash(definition) {
       name: c.name,
       input: normalizeForHash(c.input),
       ...c.expected !== void 0 ? { expected: normalizeForHash(c.expected) } : {},
-      // Grader order preserved on purpose (it maps to the result index).
+      // INVARIANT: Grader order is preserved on purpose; it maps to the result index.
       expect: c.expect.map((g) => normalizeForHash(g))
     }))
   };
@@ -2544,8 +2524,7 @@ function defineFlow(input) {
     return {
       type: step.type,
       name: step.name,
-      // Explicit 1-based order (the flow builder's convention) so the local
-      // probe hash agrees with the server's persisted step order.
+      // WHY(docs/why/packages/client/src.md#explicit-1-based-order-matches-the-flow-builders): Explicit 1-based order matches the flow builder's convention so the local hash agrees with the server
       order: typeof step.order === "number" ? step.order : index + 1,
       ...step.enabled !== void 0 ? { enabled: step.enabled } : {},
       ...typeof step.when === "string" ? { when: step.when } : {},
@@ -2847,9 +2826,6 @@ var RuntypeFlowBuilder = class {
       this.flowConfig = { name: "Untitled Flow" };
     }
   }
-  // ============================================================================
-  // Configuration Methods
-  // ============================================================================
   /**
    * Set the record configuration
    */
@@ -2893,9 +2869,6 @@ var RuntypeFlowBuilder = class {
     );
     return this;
   }
-  // ============================================================================
-  // Step Methods
-  // ============================================================================
   /**
    * Add a prompt step
    */
@@ -3679,9 +3652,6 @@ var RuntypeFlowBuilder = class {
       "Use Runtype.flows.virtual(...) or Runtype.flows.upsert(...) with inline steps to validate a flow before saving."
     );
   }
-  // ============================================================================
-  // Private Helpers
-  // ============================================================================
   /**
    * Persisted flow protocol (APQ-style): send hash-only first, retry with
    * full definition on FLOW_DEFINITION_REQUIRED. For non-upsert modes,
@@ -4757,7 +4727,8 @@ var AGENT_CONFIG_KEYS = [
   "temporal",
   "memory",
   "sandbox",
-  "tenancyStrategy"
+  "tenancyStrategy",
+  "durability"
 ];
 var AGENT_CONFIG_KEY_LIST = [...AGENT_CONFIG_KEYS].sort();
 function isPlainObject2(value) {
@@ -6043,9 +6014,6 @@ var RuntypeClient = class {
   }
 };
 var Runtype = class {
-  // ============================================================================
-  // Global Configuration
-  // ============================================================================
   /**
    * Configure the global Runtype client
    *
@@ -6083,9 +6051,6 @@ var Runtype = class {
   static createClient(config) {
     return new RuntypeClient({ ...globalConfig, ...config });
   }
-  // ============================================================================
-  // Static Namespaces
-  // ============================================================================
   /**
    * Flows namespace - Build and execute flows
    *
@@ -6327,10 +6292,150 @@ var Runtype = class {
 
 // src/version.ts
 var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "9.2.1".length > 0 ? "9.2.1" : FALLBACK_VERSION;
+var SDK_VERSION = "9.3.1".length > 0 ? "9.3.1" : FALLBACK_VERSION;
 var RUNTYPE_CLIENT_KIND = "sdk";
 var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
 
+// src/detached-reconnect.ts
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set(["execution_complete", "execution_error"]);
+var DEFAULT_MAX_DETACHED_RECONNECTS = 12;
+function observeBlock(block, into) {
+  let eventName = null;
+  for (const line of block.split("\n")) {
+    if (line.startsWith("id:")) {
+      into.lastId = line.slice(3).trim();
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim();
+      continue;
+    }
+    if (!line.startsWith("data:")) continue;
+    const raw = line.slice(5).trim();
+    if (!raw || raw === "[DONE]") continue;
+    let payload;
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) continue;
+      payload = parsed;
+    } catch {
+      continue;
+    }
+    if (typeof payload.executionId === "string") into.executionId = payload.executionId;
+    const type = typeof payload.type === "string" ? payload.type : eventName;
+    if (type && TERMINAL_EVENTS.has(type)) into.sawTerminal = true;
+    if (type === "await" && payload.awaitReason === "detached") into.sawDetach = true;
+  }
+}
+function withDetachedReconnect(response, reattach, options = {}) {
+  if (options.autoReconnect === false) return response;
+  if (!response.ok || !response.body) return response;
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("text/event-stream")) return response;
+  const maxReconnects = options.maxReconnects ?? DEFAULT_MAX_DETACHED_RECONNECTS;
+  const reconnectDelayMs = options.reconnectDelayMs ?? 0;
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const abort = new AbortController();
+  let cancelled = false;
+  let activeReader = null;
+  const stream = new ReadableStream({
+    async start(controller) {
+      const observed = {
+        lastId: null,
+        executionId: null,
+        sawTerminal: false,
+        sawDetach: false
+      };
+      let current = response;
+      let legs = 0;
+      const enqueue = (chunk) => {
+        if (cancelled) return;
+        controller.enqueue(chunk);
+      };
+      try {
+        while (!cancelled && current?.body) {
+          const reader = current.body.getReader();
+          activeReader = reader;
+          let buffer = "";
+          observed.sawDetach = false;
+          for (; ; ) {
+            const { value, done } = await reader.read();
+            if (cancelled) break;
+            if (value) {
+              enqueue(value);
+              buffer += decoder.decode(value, { stream: !done });
+              let boundary = buffer.indexOf("\n\n");
+              while (boundary >= 0) {
+                observeBlock(buffer.slice(0, boundary), observed);
+                buffer = buffer.slice(boundary + 2);
+                boundary = buffer.indexOf("\n\n");
+              }
+            }
+            if (done) break;
+          }
+          activeReader = null;
+          if (cancelled) break;
+          if (buffer.trim()) observeBlock(buffer, observed);
+          if (observed.sawTerminal || !observed.sawDetach) break;
+          if (!observed.executionId || legs >= maxReconnects) break;
+          legs += 1;
+          if (reconnectDelayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, reconnectDelayMs));
+          }
+          if (cancelled) break;
+          current = await reattach({
+            executionId: observed.executionId,
+            // WHY(docs/why/packages/client/src.md#0-replays-the-whole-turn-the-fail-open-answer-fo): '0' replays the whole turn, the fail-open answer for a leg that produced no cursor.
+            after: observed.lastId ?? "0",
+            signal: abort.signal
+          });
+          if (cancelled) {
+            await current?.body?.cancel().catch(() => {
+            });
+            break;
+          }
+          if (!current || !current.ok || !current.body) {
+            enqueue(
+              encoder.encode(
+                `event: error
+data: ${JSON.stringify({
+                  type: "error",
+                  executionId: observed.executionId,
+                  error: {
+                    code: "detached_reconnect_failed",
+                    message: "The agent detached and this client could not rejoin its stream. The execution is still running; reattach with the events route."
+                  },
+                  recoverable: false
+                })}
+
+`
+              )
+            );
+            break;
+          }
+        }
+      } finally {
+        activeReader = null;
+        if (!cancelled) controller.close();
+      }
+    },
+    async cancel(reason) {
+      cancelled = true;
+      abort.abort(reason);
+      const reader = activeReader;
+      activeReader = null;
+      if (reader) await reader.cancel(reason).catch(() => {
+      });
+    }
+  });
+  return new Response(stream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+
 // src/generated-tool-gate.ts
 var TOOL_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]{1,63}$/;
 var DEFAULT_MAX_CODE_LENGTH = 12e3;
@@ -6602,11 +6707,7 @@ function attachRuntimeToolsToDispatchRequest(request6, runtimeTools, options = {
     ...request6,
     flow: {
       ...flow,
-      // `clonedSteps` is a structural clone of `request.flow.steps` (already
-      // `FlowStepDefinition[]`); only the prompt step's `config.tools` was
-      // merged, so every step's `type` discriminant is preserved. The clone is
-      // intentionally built as loose records to merge tool config opaquely, so
-      // re-narrow to the typed step shape at this boundary.
+      // WHY(docs/why/packages/client/src.md#clonedsteps-preserves-each-steps-type-discrimina): clonedSteps preserves each step's type discriminant; re-narrow from loose records here
       steps: clonedSteps
     }
   };
@@ -7870,13 +7971,7 @@ function ensureDefaultWorkflowHooks() {
 }
 var defaultWorkflowConfig = {
   name: "default",
-  // Empty-session escalation. The counter only counts tool actions, so
-  // narration-only sessions ("I'll create the files now" with no tool calls)
-  // escalate here even though the phase recovery conditions keyed on
-  // hadTextOutput skip them: nudge after the first actionless session, signal
-  // model escalation after the second (a no-op unless the caller configured a
-  // fallback model), and stop as 'stalled' after the third — the same total
-  // session budget as before stallPolicy existed.
+  // WHY(docs/why/packages/client/src/workflows.md#empty-session-escalation-preserves-legacy-behavi): empty-session escalation preserves legacy behavior: nudge, then escalate, then stall after three
   stallPolicy: { nudgeAfter: 1, escalateModelAfter: 2, stopAfter: 3 },
   classifyVariant: "builtin:classify-task-variant",
   bootstrap: "builtin:repo-bootstrap-discovery",
@@ -7904,16 +7999,14 @@ var defaultWorkflowConfig = {
       transitionSummary: "builtin:planning-transition-summary",
       recovery: "builtin:planning-recovery",
       forceEndTurn: "builtin:planning-force-end-turn"
-      // canAcceptCompletion intentionally absent: the hand-written planning
-      // phase never defined it, and the SDK accepts completion when the slot
-      // is undefined. Keep parity.
+      // WHY(docs/why/packages/client/src/workflows.md#canacceptcompletion-is-intentionally-absent-for): canAcceptCompletion is intentionally absent for planning to keep parity with the hand-written phase
     },
     {
       name: "execution",
       description: "Execute the plan by editing target files",
       instructions: "builtin:execution-instructions",
       toolGuidance: "builtin:execution-tool-guidance",
-      // Execution never auto-advances; completion is agent-driven via TASK_COMPLETE
+      // WHY(needs-review): execution never auto-advances; completion is agent-driven via TASK_COMPLETE
       completionCriteria: { type: "never" },
       intercept: "builtin:execution-guard",
       recovery: "builtin:execution-recovery",
@@ -8083,11 +8176,11 @@ var deployWorkflow = {
   name: "deploy",
   phases: [scaffoldPhase, deployPhase],
   classifyVariant: classifyVariant2,
-  // No bootstrap context needed — we're not searching the repo
+  // WHY(needs-review): no bootstrap context needed; this workflow doesn't search the repo
   async generateBootstrapContext() {
     return void 0;
   },
-  // No candidate block — we're not editing repo files
+  // WHY(needs-review): no candidate block; this workflow doesn't edit repo files
   buildCandidateBlock() {
     return "";
   }
@@ -9458,9 +9551,7 @@ var ClientTokensEndpoint = class {
     if (params?.limit !== void 0) {
       return {
         clientTokens: response.clientTokens,
-        // The API always includes pagination when limit is supplied; the
-        // fallback mirrors the server's own envelope math so the paged
-        // overload stays total against older API deployments.
+        // WHY(docs/why/packages/client/src.md#the-fallback-mirrors-the-servers-own-envelope-ma): The fallback mirrors the server's own envelope math so paging stays correct against older API deployments.
         pagination: response.pagination ?? {
           limit: params.limit,
           offset: params.offset ?? 0,
@@ -9711,6 +9802,14 @@ function appendRuntimeToolsToAgentRequest(request6, runtimeTools) {
     }
   };
 }
+function buildAgentAdmissionHeaders(options) {
+  if (!options) return {};
+  const headers = {};
+  if (options.concurrency) headers["x-runtype-concurrency"] = options.concurrency;
+  if (options.coalesce) headers["x-runtype-coalesce"] = "true";
+  if (options.idempotencyKey) headers["idempotency-key"] = options.idempotencyKey;
+  return headers;
+}
 var _AgentsEndpoint = class _AgentsEndpoint {
   constructor(client) {
     this.client = client;
@@ -9802,18 +9901,22 @@ var _AgentsEndpoint = class _AgentsEndpoint {
   /**
    * Execute an agent (non-streaming)
    */
-  async execute(id, data) {
-    return this.client.post(`/agents/${id}/execute`, {
-      ...data,
-      streamResponse: false
-    });
+  async execute(id, data, options) {
+    return this.client.post(
+      `/agents/${id}/execute`,
+      {
+        ...data,
+        streamResponse: false
+      },
+      buildAgentAdmissionHeaders(options)
+    );
   }
   /** Start an agent execution and return its durable handle immediately. */
-  async executeAsync(id, data) {
+  async executeAsync(id, data, options) {
     return this.client.post(
       `/agents/${id}/execute`,
       { ...data, streamResponse: false },
-      { Prefer: "respond-async" }
+      { Prefer: "respond-async", ...buildAgentAdmissionHeaders(options) }
     );
   }
   /**
@@ -9835,14 +9938,42 @@ var _AgentsEndpoint = class _AgentsEndpoint {
    * ```
    */
   async executeStream(id, data, init) {
-    return this.client.requestStream(`/agents/${id}/execute`, {
+    const admissionHeaders = buildAgentAdmissionHeaders(init);
+    const response = await this.client.requestStream(`/agents/${id}/execute`, {
       method: "POST",
       body: JSON.stringify({
         ...data,
         streamResponse: true
       }),
+      ...Object.keys(admissionHeaders).length > 0 ? { headers: admissionHeaders } : {},
       ...init?.signal ? { signal: init.signal } : {}
     });
+    return withDetachedReconnect(
+      response,
+      this.buildDetachedReattach(id, data, init?.signal),
+      init ?? {}
+    );
+  }
+  /**
+   * The `?after=` reattach leg every durable agent stream is followed with.
+   *
+   * Shared by `executeStream` and by the local-tool loop's RESUME leg: a
+   * durable resume answers on the same watch-lease contract as the original
+   * execute, so its socket can close on `awaitReason: 'detached'` too. Building
+   * it once is what keeps the two from drifting into different cursor or
+   * conversation-key behavior.
+   */
+  buildDetachedReattach(id, data, signal) {
+    return async ({ executionId, after }) => {
+      const named = data?.conversationId;
+      const conversationId = typeof named === "string" ? named : "";
+      const query = new URLSearchParams({ after });
+      if (conversationId) query.set("conversationId", conversationId);
+      return this.client.requestStream(`/agents/${id}/executions/${executionId}/events?${query.toString()}`, {
+        method: "GET",
+        ...signal ? { signal } : {}
+      }).catch(() => null);
+    };
   }
   /**
    * Execute an agent with streaming and callbacks
@@ -10006,7 +10137,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
             callbacks?.onTurnComplete?.(event);
           },
           onAgentPaused: (event) => {
-            pausedEvent = event;
+            if (event.awaitReason !== "detached") pausedEvent = event;
             callbacks?.onAgentPaused?.(event);
           },
           onAgentComplete: (event) => {
@@ -10172,8 +10303,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
             iterations: 1,
             stopReason: "end_turn",
             completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            // Carry the spend observed so far so the interrupted session's
-            // cost still lands in marathon totals and budget accounting
+            // WHY(docs/why/packages/client/src.md#carries-accumulated-spend-so-an-interrupted-sess): Carries accumulated spend so an interrupted session's cost still lands in totals
             totalCost: lastKnownCost,
             ...lastKnownTokens ? { totalTokens: lastKnownTokens } : {},
             finalOutput: [
@@ -10187,7 +10317,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
         }
         let resumeResponse;
         try {
-          resumeResponse = await this.client.requestStream(`/agents/${id}/resume`, {
+          const rawResumeResponse = await this.client.requestStream(`/agents/${id}/resume`, {
             method: "POST",
             body: JSON.stringify({
               executionId,
@@ -10197,6 +10327,11 @@ var _AgentsEndpoint = class _AgentsEndpoint {
             }),
             ...abortSignal ? { signal: abortSignal } : {}
           });
+          resumeResponse = withDetachedReconnect(
+            rawResumeResponse,
+            this.buildDetachedReattach(id, data, abortSignal),
+            {}
+          );
         } catch (error) {
           if (abortSignal?.aborted) return finishAborted(executionId);
           throw error;
@@ -10222,7 +10357,6 @@ var _AgentsEndpoint = class _AgentsEndpoint {
       return null;
     }
   }
-  // ─── Long-Task Agent Execution ───────────────────────────────────────
   createEmptyToolTrace() {
     return {
       entries: [],
@@ -12997,12 +13131,7 @@ var RuntypeClient2 = class {
     this.timeout = config.timeout === void 0 ? 3e4 : config.timeout;
     this.headers = {
       "Content-Type": "application/json",
-      // Advertise client identity + version so the API can attribute SDK traffic
-      // (see detectActorSource in apps/api/src/lib/audit-log.ts). Defaults come
-      // first so callers that wrap this client with their own attribution — the
-      // CLI sends `X-Runtype-Client: cli` + `runtype-cli/<v>` — override them.
-      // `User-Agent` is a forbidden header in browsers and is silently dropped
-      // there; `X-Runtype-Client` is the reliable cross-environment signal.
+      // WHY(docs/why/packages/client/src.md#user-agent-is-a-forbidden-header-in-browsers-and): User-Agent is a forbidden header in browsers and is silently dropped; X-Runtype-Client is the reliable
       "X-Runtype-Client": RUNTYPE_CLIENT_KIND,
       "User-Agent": SDK_USER_AGENT,
       ...config.headers || {}
@@ -13063,8 +13192,7 @@ var RuntypeClient2 = class {
       {
         dispatch: (config) => this.dispatch.executeStream(config),
         runWithLocalTools: (config, tools, callbacks, opts) => this.runWithLocalTools(config, tools, callbacks, opts),
-        // Validation capability for ClientFlowBuilder.validate() — reuses the
-        // client's JSON POST transport (zero new HTTP plumbing).
+        // WHY(docs/why/packages/client/src.md#clientflowbuilder-validate-reuses-the-clients-js): ClientFlowBuilder.validate() reuses the client's JSON POST transport instead of new HTTP plumbing.
         post: (path, data) => this.post(path, data)
       },
       name
@@ -13318,8 +13446,7 @@ var RuntypeClient2 = class {
     const response = await this.makeRequest(url, {
       method: "POST",
       headers,
-      // TS 5.7 types Uint8Array over ArrayBufferLike, which no longer
-      // overlaps DOM BodyInit; the runtime value is a valid fetch body.
+      // WORKAROUND(docs/why/packages/client/src.md#ts-5-7-types-uint8array-over-arraybufferlike-whi): TS 5.7 types Uint8Array over ArrayBufferLike, which no longer overlaps DOM BodyInit, though the
       body
     });
     return transformResponse(response);
@@ -14258,6 +14385,7 @@ export {
   CollectionsEndpoint,
   ContextTemplatesEndpoint,
   ConversationsEndpoint,
+  DEFAULT_MAX_DETACHED_RECONNECTS,
   DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS,
   DEFAULT_STALL_STOP_AFTER,
   DispatchEndpoint,
@@ -14316,6 +14444,7 @@ export {
   UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest,
   attachRuntimeToolsToDispatchRequest,
+  buildAgentAdmissionHeaders,
   buildEmptySessionNudge,
   buildGeneratedRuntimeToolGateOutput,
   buildLedgerOffloadReference,
@@ -14405,5 +14534,6 @@ export {
   unregisterWorkflowHook,
   usedNoTools,
   validJson,
+  withDetachedReconnect,
   withUnifiedEvents
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/sdk",
-  "version": "9.2.1",
+  "version": "9.3.1",
   "type": "module",
   "description": "TypeScript SDK for the Runtype API with fluent methods. Use it to quickly realize AI products, agents, and workflows.",
   "main": "dist/index.cjs",