tianshu-harness 3.23.0

package/dist/streamableHttp-V67CNJMO.js

@@ -0,0 +1,447 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  UnauthorizedError,
+  auth,
+  createFetchWithInit,
+  createParser,
+  extractWWWAuthenticateParams,
+  normalizeHeaders
+} from "./chunk-TWNHOSDT.js";
+import {
+  JSONRPCMessageSchema,
+  isInitializedNotification,
+  isJSONRPCRequest,
+  isJSONRPCResultResponse
+} from "./chunk-MOZPLHSU.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
+init_esm_shims();
+
+// node_modules/eventsource-parser/dist/stream.js
+init_esm_shims();
+var EventSourceParserStream = class extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+};
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
+var DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
+  initialReconnectionDelay: 1e3,
+  maxReconnectionDelay: 3e4,
+  reconnectionDelayGrowFactor: 1.5,
+  maxRetries: 2
+};
+var StreamableHTTPError = class extends Error {
+  constructor(code, message) {
+    super(`Streamable HTTP error: ${message}`);
+    this.code = code;
+  }
+};
+var StreamableHTTPClientTransport = class {
+  constructor(url, opts) {
+    this._hasCompletedAuthFlow = false;
+    this._url = url;
+    this._resourceMetadataUrl = void 0;
+    this._scope = void 0;
+    this._requestInit = opts?.requestInit;
+    this._authProvider = opts?.authProvider;
+    this._fetch = opts?.fetch;
+    this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+    this._sessionId = opts?.sessionId;
+    this._reconnectionOptions = opts?.reconnectionOptions ?? DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
+  }
+  async _authThenStart() {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    let result;
+    try {
+      result = await auth(this._authProvider, {
+        serverUrl: this._url,
+        resourceMetadataUrl: this._resourceMetadataUrl,
+        scope: this._scope,
+        fetchFn: this._fetchWithInit
+      });
+    } catch (error) {
+      this.onerror?.(error);
+      throw error;
+    }
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError();
+    }
+    return await this._startOrAuthSse({ resumptionToken: void 0 });
+  }
+  async _commonHeaders() {
+    const headers = {};
+    if (this._authProvider) {
+      const tokens = await this._authProvider.tokens();
+      if (tokens) {
+        headers["Authorization"] = `Bearer ${tokens.access_token}`;
+      }
+    }
+    if (this._sessionId) {
+      headers["mcp-session-id"] = this._sessionId;
+    }
+    if (this._protocolVersion) {
+      headers["mcp-protocol-version"] = this._protocolVersion;
+    }
+    const extraHeaders = normalizeHeaders(this._requestInit?.headers);
+    return new Headers({
+      ...headers,
+      ...extraHeaders
+    });
+  }
+  async _startOrAuthSse(options) {
+    const { resumptionToken } = options;
+    try {
+      const headers = await this._commonHeaders();
+      headers.set("Accept", "text/event-stream");
+      if (resumptionToken) {
+        headers.set("last-event-id", resumptionToken);
+      }
+      const response = await (this._fetch ?? fetch)(this._url, {
+        method: "GET",
+        headers,
+        signal: this._abortController?.signal
+      });
+      if (!response.ok) {
+        await response.body?.cancel();
+        if (response.status === 401 && this._authProvider) {
+          return await this._authThenStart();
+        }
+        if (response.status === 405) {
+          return;
+        }
+        throw new StreamableHTTPError(response.status, `Failed to open SSE stream: ${response.statusText}`);
+      }
+      this._handleSseStream(response.body, options, true);
+    } catch (error) {
+      this.onerror?.(error);
+      throw error;
+    }
+  }
+  /**
+   * Calculates the next reconnection delay using  backoff algorithm
+   *
+   * @param attempt Current reconnection attempt count for the specific stream
+   * @returns Time to wait in milliseconds before next reconnection attempt
+   */
+  _getNextReconnectionDelay(attempt) {
+    if (this._serverRetryMs !== void 0) {
+      return this._serverRetryMs;
+    }
+    const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
+    const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
+    const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
+    return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay);
+  }
+  /**
+   * Schedule a reconnection attempt using server-provided retry interval or backoff
+   *
+   * @param lastEventId The ID of the last received event for resumability
+   * @param attemptCount Current reconnection attempt count for this specific stream
+   */
+  _scheduleReconnection(options, attemptCount = 0) {
+    const maxRetries = this._reconnectionOptions.maxRetries;
+    if (attemptCount >= maxRetries) {
+      this.onerror?.(new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
+      return;
+    }
+    const delay = this._getNextReconnectionDelay(attemptCount);
+    this._reconnectionTimeout = setTimeout(() => {
+      this._startOrAuthSse(options).catch((error) => {
+        this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
+        this._scheduleReconnection(options, attemptCount + 1);
+      });
+    }, delay);
+  }
+  _handleSseStream(stream, options, isReconnectable) {
+    if (!stream) {
+      return;
+    }
+    const { onresumptiontoken, replayMessageId } = options;
+    let lastEventId;
+    let hasPrimingEvent = false;
+    let receivedResponse = false;
+    const processStream = async () => {
+      try {
+        const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream({
+          onRetry: (retryMs) => {
+            this._serverRetryMs = retryMs;
+          }
+        })).getReader();
+        while (true) {
+          const { value: event, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          if (event.id) {
+            lastEventId = event.id;
+            hasPrimingEvent = true;
+            onresumptiontoken?.(event.id);
+          }
+          if (!event.data) {
+            continue;
+          }
+          if (!event.event || event.event === "message") {
+            try {
+              const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
+              if (isJSONRPCResultResponse(message)) {
+                receivedResponse = true;
+                if (replayMessageId !== void 0) {
+                  message.id = replayMessageId;
+                }
+              }
+              this.onmessage?.(message);
+            } catch (error) {
+              this.onerror?.(error);
+            }
+          }
+        }
+        const canResume = isReconnectable || hasPrimingEvent;
+        const needsReconnect = canResume && !receivedResponse;
+        if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          this._scheduleReconnection({
+            resumptionToken: lastEventId,
+            onresumptiontoken,
+            replayMessageId
+          }, 0);
+        }
+      } catch (error) {
+        this.onerror?.(new Error(`SSE stream disconnected: ${error}`));
+        const canResume = isReconnectable || hasPrimingEvent;
+        const needsReconnect = canResume && !receivedResponse;
+        if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          try {
+            this._scheduleReconnection({
+              resumptionToken: lastEventId,
+              onresumptiontoken,
+              replayMessageId
+            }, 0);
+          } catch (error2) {
+            this.onerror?.(new Error(`Failed to reconnect: ${error2 instanceof Error ? error2.message : String(error2)}`));
+          }
+        }
+      }
+    };
+    processStream();
+  }
+  async start() {
+    if (this._abortController) {
+      throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+    }
+    this._abortController = new AbortController();
+  }
+  /**
+   * Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth.
+   */
+  async finishAuth(authorizationCode) {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    const result = await auth(this._authProvider, {
+      serverUrl: this._url,
+      authorizationCode,
+      resourceMetadataUrl: this._resourceMetadataUrl,
+      scope: this._scope,
+      fetchFn: this._fetchWithInit
+    });
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError("Failed to authorize");
+    }
+  }
+  async close() {
+    if (this._reconnectionTimeout) {
+      clearTimeout(this._reconnectionTimeout);
+      this._reconnectionTimeout = void 0;
+    }
+    this._abortController?.abort();
+    this.onclose?.();
+  }
+  async send(message, options) {
+    try {
+      const { resumptionToken, onresumptiontoken } = options || {};
+      if (resumptionToken) {
+        this._startOrAuthSse({ resumptionToken, replayMessageId: isJSONRPCRequest(message) ? message.id : void 0 }).catch((err) => this.onerror?.(err));
+        return;
+      }
+      const headers = await this._commonHeaders();
+      headers.set("content-type", "application/json");
+      headers.set("accept", "application/json, text/event-stream");
+      const init = {
+        ...this._requestInit,
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: this._abortController?.signal
+      };
+      const response = await (this._fetch ?? fetch)(this._url, init);
+      const sessionId = response.headers.get("mcp-session-id");
+      if (sessionId) {
+        this._sessionId = sessionId;
+      }
+      if (!response.ok) {
+        const text = await response.text().catch(() => null);
+        if (response.status === 401 && this._authProvider) {
+          if (this._hasCompletedAuthFlow) {
+            throw new StreamableHTTPError(401, "Server returned 401 after successful authentication");
+          }
+          const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+          this._resourceMetadataUrl = resourceMetadataUrl;
+          this._scope = scope;
+          const result = await auth(this._authProvider, {
+            serverUrl: this._url,
+            resourceMetadataUrl: this._resourceMetadataUrl,
+            scope: this._scope,
+            fetchFn: this._fetchWithInit
+          });
+          if (result !== "AUTHORIZED") {
+            throw new UnauthorizedError();
+          }
+          this._hasCompletedAuthFlow = true;
+          return this.send(message);
+        }
+        if (response.status === 403 && this._authProvider) {
+          const { resourceMetadataUrl, scope, error } = extractWWWAuthenticateParams(response);
+          if (error === "insufficient_scope") {
+            const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+            if (this._lastUpscopingHeader === wwwAuthHeader) {
+              throw new StreamableHTTPError(403, "Server returned 403 after trying upscoping");
+            }
+            if (scope) {
+              this._scope = scope;
+            }
+            if (resourceMetadataUrl) {
+              this._resourceMetadataUrl = resourceMetadataUrl;
+            }
+            this._lastUpscopingHeader = wwwAuthHeader ?? void 0;
+            const result = await auth(this._authProvider, {
+              serverUrl: this._url,
+              resourceMetadataUrl: this._resourceMetadataUrl,
+              scope: this._scope,
+              fetchFn: this._fetch
+            });
+            if (result !== "AUTHORIZED") {
+              throw new UnauthorizedError();
+            }
+            return this.send(message);
+          }
+        }
+        throw new StreamableHTTPError(response.status, `Error POSTing to endpoint: ${text}`);
+      }
+      this._hasCompletedAuthFlow = false;
+      this._lastUpscopingHeader = void 0;
+      if (response.status === 202) {
+        await response.body?.cancel();
+        if (isInitializedNotification(message)) {
+          this._startOrAuthSse({ resumptionToken: void 0 }).catch((err) => this.onerror?.(err));
+        }
+        return;
+      }
+      const messages = Array.isArray(message) ? message : [message];
+      const hasRequests = messages.filter((msg) => "method" in msg && "id" in msg && msg.id !== void 0).length > 0;
+      const contentType = response.headers.get("content-type");
+      if (hasRequests) {
+        if (contentType?.includes("text/event-stream")) {
+          this._handleSseStream(response.body, { onresumptiontoken }, false);
+        } else if (contentType?.includes("application/json")) {
+          const data = await response.json();
+          const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)];
+          for (const msg of responseMessages) {
+            this.onmessage?.(msg);
+          }
+        } else {
+          await response.body?.cancel();
+          throw new StreamableHTTPError(-1, `Unexpected content type: ${contentType}`);
+        }
+      } else {
+        await response.body?.cancel();
+      }
+    } catch (error) {
+      this.onerror?.(error);
+      throw error;
+    }
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  /**
+   * Terminates the current session by sending a DELETE request to the server.
+   *
+   * Clients that no longer need a particular session
+   * (e.g., because the user is leaving the client application) SHOULD send an
+   * HTTP DELETE to the MCP endpoint with the Mcp-Session-Id header to explicitly
+   * terminate the session.
+   *
+   * The server MAY respond with HTTP 405 Method Not Allowed, indicating that
+   * the server does not allow clients to terminate sessions.
+   */
+  async terminateSession() {
+    if (!this._sessionId) {
+      return;
+    }
+    try {
+      const headers = await this._commonHeaders();
+      const init = {
+        ...this._requestInit,
+        method: "DELETE",
+        headers,
+        signal: this._abortController?.signal
+      };
+      const response = await (this._fetch ?? fetch)(this._url, init);
+      await response.body?.cancel();
+      if (!response.ok && response.status !== 405) {
+        throw new StreamableHTTPError(response.status, `Failed to terminate session: ${response.statusText}`);
+      }
+      this._sessionId = void 0;
+    } catch (error) {
+      this.onerror?.(error);
+      throw error;
+    }
+  }
+  setProtocolVersion(version) {
+    this._protocolVersion = version;
+  }
+  get protocolVersion() {
+    return this._protocolVersion;
+  }
+  /**
+   * Resume an SSE stream from a previous event ID.
+   * Opens a GET SSE connection with Last-Event-ID header to replay missed events.
+   *
+   * @param lastEventId The event ID to resume from
+   * @param options Optional callback to receive new resumption tokens
+   */
+  async resumeStream(lastEventId, options) {
+    await this._startOrAuthSse({
+      resumptionToken: lastEventId,
+      onresumptiontoken: options?.onresumptiontoken
+    });
+  }
+};
+export {
+  StreamableHTTPClientTransport,
+  StreamableHTTPError
+};

package/dist/task-contract-6XHBNJQK.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  advanceContractStatus,
+  classifyPlanMethodology,
+  classifyTaskDepth,
+  classifyTurnMode,
+  contractStatusFromPhaseClass,
+  extractTaskContract,
+  isActionableTurn,
+  isRefactorObjective,
+  isSocialOrTrivial,
+  mergeFollowUpIntoContract,
+  renderContractProjection,
+  renderTaskAnchor
+} from "./chunk-P6GJOVO6.js";
+import "./chunk-TPI73L57.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  advanceContractStatus,
+  classifyPlanMethodology,
+  classifyTaskDepth,
+  classifyTurnMode,
+  contractStatusFromPhaseClass,
+  extractTaskContract,
+  isActionableTurn,
+  isRefactorObjective,
+  isSocialOrTrivial,
+  mergeFollowUpIntoContract,
+  renderContractProjection,
+  renderTaskAnchor
+};

package/dist/task-ledger-3K4TJIER.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  createTaskLedger
+} from "./chunk-2XN7PM4N.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  createTaskLedger
+};

package/dist/team-orchestrate-S6NHZP7X.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  TEAM_TIMEOUT_CEIL_MS,
+  collectAllDirtyRows,
+  collectBlockedAttribution,
+  createTeamOrchestrateTool,
+  formatTeamSummary,
+  teamOrchestrateTimeoutMs
+} from "./chunk-D54ZWG4T.js";
+import {
+  teamReviewChangedFiles,
+  teamReviewFocusHint,
+  teamReviewForceLevel
+} from "./chunk-R43HJCDX.js";
+import "./chunk-D4PTYFOG.js";
+import "./chunk-AERM3VGP.js";
+import "./chunk-RK3JHWPT.js";
+import "./chunk-NH6VIOAR.js";
+import "./chunk-S4K4L6IM.js";
+import "./chunk-3VGD2FXB.js";
+import "./chunk-UXNLELW6.js";
+import "./chunk-TVHW77C7.js";
+import "./chunk-EHHUASO5.js";
+import "./chunk-LA6IPTGH.js";
+import "./chunk-HBVF6BWO.js";
+import "./chunk-UHGLFRZE.js";
+import "./chunk-4QJ3Y5JM.js";
+import "./chunk-CGOADM2X.js";
+import "./chunk-ZMZCZNKU.js";
+import "./chunk-7RDOV3DF.js";
+import "./chunk-6HSVXHCZ.js";
+import "./chunk-OHSV42QB.js";
+import "./chunk-ADIVZ2D5.js";
+import "./chunk-GD4ZNZ7W.js";
+import "./chunk-Z5Z3JHJY.js";
+import "./chunk-35H7GVNR.js";
+import "./chunk-SUJERP5I.js";
+import "./chunk-CI4R6P2B.js";
+import "./chunk-XU2YXCDL.js";
+import "./chunk-ETHFACAB.js";
+import "./chunk-THKDVSEC.js";
+import "./chunk-UFMN76QD.js";
+import "./chunk-ER5JW2QZ.js";
+import "./chunk-CGFZGR7G.js";
+import "./chunk-P5KJURUR.js";
+import "./chunk-WMUWEO2C.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-7KUCBNLB.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  TEAM_TIMEOUT_CEIL_MS,
+  collectAllDirtyRows,
+  collectBlockedAttribution,
+  createTeamOrchestrateTool,
+  formatTeamSummary,
+  teamOrchestrateTimeoutMs,
+  teamReviewChangedFiles,
+  teamReviewFocusHint,
+  teamReviewForceLevel
+};

package/dist/title-extract-QX4XGCYN.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/title-extract.ts
+init_esm_shims();
+var MAX_INPUT_CHARS = 800;
+var MAX_TITLE_CHARS = 40;
+var TITLE_SYSTEM = `You generate a concise session title (<=40 chars) from the user's first message in a coding assistant session.
+
+Rules:
+- Output ONLY the title text. No quotes, no markdown, no explanation.
+- <=40 characters. Truncate gracefully if the natural title would exceed it.
+- Use the same language as the user's message (Chinese in \u2192 Chinese out, English in \u2192 English out).
+- Imperative or noun phrase, not a full sentence ("\u52A0\u6392\u5E8F\u6309\u94AE" not "\u7528\u6237\u60F3\u8981\u52A0\u4E00\u4E2A\u6392\u5E8F\u6309\u94AE").
+- Strip pleasantries ("\u5E2E\u6211", "\u8BF7", "\u80FD\u4E0D\u80FD", "can you") and meta talk ("\u8FD9\u4E2A\u4EFB\u52A1", "\u9700\u6C42\u662F").
+- No trailing punctuation.`;
+function buildTitleUser(firstMessage) {
+  const truncated = firstMessage.length > MAX_INPUT_CHARS ? firstMessage.slice(0, MAX_INPUT_CHARS) : firstMessage;
+  return `First message:
+${truncated}
+
+Generate a session title (<=40 chars, same language as the message).`;
+}
+function cleanTitle(raw) {
+  let t = raw.trim();
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'") || t.startsWith("\u300C") && t.endsWith("\u300D") || t.startsWith("\u201C") && t.endsWith("\u201D")) {
+    t = t.slice(1, -1).trim();
+  }
+  t = t.replace(/^(title|标题)\s*[:：]\s*/i, "");
+  t = t.replace(/\s+/g, " ").trim();
+  if (!t) return null;
+  if (t.length > MAX_TITLE_CHARS) t = t.slice(0, MAX_TITLE_CHARS).trim();
+  return t || null;
+}
+async function extractSessionTitle(firstMessage, complete, signal) {
+  try {
+    const raw = await complete(TITLE_SYSTEM, buildTitleUser(firstMessage), signal);
+    return cleanTitle(raw);
+  } catch {
+    return null;
+  }
+}
+export {
+  buildTitleUser,
+  cleanTitle,
+  extractSessionTitle
+};

package/dist/todo-QDXGRZZP.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  TODO_TOOL,
+  createTodoTool,
+  defaultStore,
+  getTodoRegressionStats,
+  getTodos,
+  loadTodos,
+  setTodoSession,
+  setTodos
+} from "./chunk-AE3P3F6W.js";
+import "./chunk-LH5VCGLB.js";
+import "./chunk-6S5FPUS7.js";
+import "./chunk-EXXICUIW.js";
+import "./chunk-QARAGUXX.js";
+import "./chunk-DEBI37QB.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  TODO_TOOL,
+  createTodoTool,
+  defaultStore,
+  getTodoRegressionStats,
+  getTodos,
+  loadTodos,
+  setTodoSession,
+  setTodos
+};

package/dist/todo-store-V3TTO5AH.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  TODO_EMPTY_RESULT,
+  TodoStore
+} from "./chunk-DEBI37QB.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  TODO_EMPTY_RESULT,
+  TodoStore
+};

package/dist/tool-preset-LU5BYEDZ.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  __resetToolPresetForTest,
+  invalidateToolPreset,
+  presetIncludes,
+  resolveToolPreset
+} from "./chunk-ER5JW2QZ.js";
+import "./chunk-CGFZGR7G.js";
+import "./chunk-P5KJURUR.js";
+import "./chunk-WMUWEO2C.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-7KUCBNLB.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  __resetToolPresetForTest,
+  invalidateToolPreset,
+  presetIncludes,
+  resolveToolPreset
+};

package/dist/tool-tiers-GD742YBN.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  ALL_KNOWN_TOOLS,
+  CORE_TOOLS,
+  EXTENDED_TOOLS,
+  gateToolDefinitions,
+  isCoreTool,
+  isExtendedTool,
+  resolveMainToolTier,
+  validateTierInvariant
+} from "./chunk-JSXWIWWJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  ALL_KNOWN_TOOLS,
+  CORE_TOOLS,
+  EXTENDED_TOOLS,
+  gateToolDefinitions,
+  isCoreTool,
+  isExtendedTool,
+  resolveMainToolTier,
+  validateTierInvariant
+};