@truefoundry/trueforge-core 0.0.0 → 0.1.0-rc.0

package/dist/agent-session/store/SessionStoreErrors.mjs

@@ -0,0 +1,92 @@
+// src/agent-session/store/SessionStoreErrors.ts
+var SessionStoreConflictError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SessionStoreConflictError";
+  }
+};
+var SessionStoreNotFoundError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SessionStoreNotFoundError";
+  }
+};
+var SessionStoreInvariantError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SessionStoreInvariantError";
+  }
+};
+var SessionNotFoundError = class extends SessionStoreNotFoundError {
+  session_id;
+  constructor(session_id) {
+    super(`Session not found: ${session_id}`);
+    this.name = "SessionNotFoundError";
+    this.session_id = session_id;
+  }
+};
+var TurnNotFoundError = class extends SessionStoreNotFoundError {
+  turn_id;
+  constructor(turn_id) {
+    super(`Turn not found: ${turn_id}`);
+    this.name = "TurnNotFoundError";
+    this.turn_id = turn_id;
+  }
+};
+var SessionAlreadyExistsError = class extends SessionStoreConflictError {
+  session_id;
+  constructor(session_id, options) {
+    super(`Session already exists: ${session_id}`, options);
+    this.name = "SessionAlreadyExistsError";
+    this.session_id = session_id;
+  }
+};
+var TurnAlreadyExistsError = class extends SessionStoreConflictError {
+  turn_id;
+  constructor(turn_id, options) {
+    super(`Turn already exists: ${turn_id}`, options);
+    this.name = "TurnAlreadyExistsError";
+    this.turn_id = turn_id;
+  }
+};
+var PreviousTurnRunningError = class extends SessionStoreConflictError {
+  previous_turn_id;
+  constructor(previous_turn_id) {
+    super(
+      `Previous turn ${previous_turn_id} is still running; freezeAndGetTurn must be called before creating a successor`
+    );
+    this.name = "PreviousTurnRunningError";
+    this.previous_turn_id = previous_turn_id;
+  }
+};
+var TurnNotRunningError = class extends SessionStoreConflictError {
+  turn_id;
+  state;
+  constructor(turn_id, state) {
+    super(`Turn ${turn_id} is not running (${state.status})`);
+    this.name = "TurnNotRunningError";
+    this.turn_id = turn_id;
+    this.state = state;
+  }
+};
+var InvalidPageTokenError = class extends SessionStoreConflictError {
+  token;
+  constructor(token) {
+    super(`Invalid page token: ${token}`);
+    this.name = "InvalidPageTokenError";
+    this.token = token;
+  }
+};
+export {
+  InvalidPageTokenError,
+  PreviousTurnRunningError,
+  SessionAlreadyExistsError,
+  SessionNotFoundError,
+  SessionStoreConflictError,
+  SessionStoreInvariantError,
+  SessionStoreNotFoundError,
+  TurnAlreadyExistsError,
+  TurnNotFoundError,
+  TurnNotRunningError
+};
+//# sourceMappingURL=SessionStoreErrors.mjs.map

package/dist/agent-session/store/SessionStoreErrors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agent-session/store/SessionStoreErrors.ts"],"sourcesContent":["import type { TerminalTurnState } from '../schemas/turn';\n\n/** Store conflict (e.g. first-terminal-wins violation, concurrent createTurn). */\nexport abstract class SessionStoreConflictError extends Error {\n  constructor(message: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = 'SessionStoreConflictError';\n  }\n}\n\n/** Store not-found (session or turn missing). */\nexport abstract class SessionStoreNotFoundError extends Error {\n  constructor(message: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = 'SessionStoreNotFoundError';\n  }\n}\n\n/** Implementation bug or thread misuse — not mapped to 4xx by API handlers. */\nexport class SessionStoreInvariantError extends Error {\n  constructor(message: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = 'SessionStoreInvariantError';\n  }\n}\n\nexport class SessionNotFoundError extends SessionStoreNotFoundError {\n  readonly session_id: string;\n\n  constructor(session_id: string) {\n    super(`Session not found: ${session_id}`);\n    this.name = 'SessionNotFoundError';\n    this.session_id = session_id;\n  }\n}\n\nexport class TurnNotFoundError extends SessionStoreNotFoundError {\n  readonly turn_id: string;\n\n  constructor(turn_id: string) {\n    super(`Turn not found: ${turn_id}`);\n    this.name = 'TurnNotFoundError';\n    this.turn_id = turn_id;\n  }\n}\n\nexport class SessionAlreadyExistsError extends SessionStoreConflictError {\n  readonly session_id: string;\n\n  constructor(session_id: string, options?: ErrorOptions) {\n    super(`Session already exists: ${session_id}`, options);\n    this.name = 'SessionAlreadyExistsError';\n    this.session_id = session_id;\n  }\n}\n\nexport class TurnAlreadyExistsError extends SessionStoreConflictError {\n  readonly turn_id: string;\n\n  constructor(turn_id: string, options?: ErrorOptions) {\n    super(`Turn already exists: ${turn_id}`, options);\n    this.name = 'TurnAlreadyExistsError';\n    this.turn_id = turn_id;\n  }\n}\n\nexport class PreviousTurnRunningError extends SessionStoreConflictError {\n  readonly previous_turn_id: string;\n\n  constructor(previous_turn_id: string) {\n    super(\n      `Previous turn ${previous_turn_id} is still running; freezeAndGetTurn must be called before creating a successor`,\n    );\n    this.name = 'PreviousTurnRunningError';\n    this.previous_turn_id = previous_turn_id;\n  }\n}\n\nexport class TurnNotRunningError extends SessionStoreConflictError {\n  readonly turn_id: string;\n  readonly state: TerminalTurnState;\n\n  constructor(turn_id: string, state: TerminalTurnState) {\n    super(`Turn ${turn_id} is not running (${state.status})`);\n    this.name = 'TurnNotRunningError';\n    this.turn_id = turn_id;\n    this.state = state;\n  }\n}\n\nexport class InvalidPageTokenError extends SessionStoreConflictError {\n  readonly token: string;\n\n  constructor(token: string) {\n    super(`Invalid page token: ${token}`);\n    this.name = 'InvalidPageTokenError';\n    this.token = token;\n  }\n}\n"],"mappings":";AAGO,IAAe,4BAAf,cAAiD,MAAM;AAAA,EAC5D,YAAY,SAAiB,SAAwB;AACnD,UAAM,SAAS,OAAO;AACtB,SAAK,OAAO;AAAA,EACd;AACF;AAGO,IAAe,4BAAf,cAAiD,MAAM;AAAA,EAC5D,YAAY,SAAiB,SAAwB;AACnD,UAAM,SAAS,OAAO;AACtB,SAAK,OAAO;AAAA,EACd;AACF;AAGO,IAAM,6BAAN,cAAyC,MAAM;AAAA,EACpD,YAAY,SAAiB,SAAwB;AACnD,UAAM,SAAS,OAAO;AACtB,SAAK,OAAO;AAAA,EACd;AACF;AAEO,IAAM,uBAAN,cAAmC,0BAA0B;AAAA,EACzD;AAAA,EAET,YAAY,YAAoB;AAC9B,UAAM,sBAAsB,UAAU,EAAE;AACxC,SAAK,OAAO;AACZ,SAAK,aAAa;AAAA,EACpB;AACF;AAEO,IAAM,oBAAN,cAAgC,0BAA0B;AAAA,EACtD;AAAA,EAET,YAAY,SAAiB;AAC3B,UAAM,mBAAmB,OAAO,EAAE;AAClC,SAAK,OAAO;AACZ,SAAK,UAAU;AAAA,EACjB;AACF;AAEO,IAAM,4BAAN,cAAwC,0BAA0B;AAAA,EAC9D;AAAA,EAET,YAAY,YAAoB,SAAwB;AACtD,UAAM,2BAA2B,UAAU,IAAI,OAAO;AACtD,SAAK,OAAO;AACZ,SAAK,aAAa;AAAA,EACpB;AACF;AAEO,IAAM,yBAAN,cAAqC,0BAA0B;AAAA,EAC3D;AAAA,EAET,YAAY,SAAiB,SAAwB;AACnD,UAAM,wBAAwB,OAAO,IAAI,OAAO;AAChD,SAAK,OAAO;AACZ,SAAK,UAAU;AAAA,EACjB;AACF;AAEO,IAAM,2BAAN,cAAuC,0BAA0B;AAAA,EAC7D;AAAA,EAET,YAAY,kBAA0B;AACpC;AAAA,MACE,iBAAiB,gBAAgB;AAAA,IACnC;AACA,SAAK,OAAO;AACZ,SAAK,mBAAmB;AAAA,EAC1B;AACF;AAEO,IAAM,sBAAN,cAAkC,0BAA0B;AAAA,EACxD;AAAA,EACA;AAAA,EAET,YAAY,SAAiB,OAA0B;AACrD,UAAM,QAAQ,OAAO,oBAAoB,MAAM,MAAM,GAAG;AACxD,SAAK,OAAO;AACZ,SAAK,UAAU;AACf,SAAK,QAAQ;AAAA,EACf;AACF;AAEO,IAAM,wBAAN,cAAoC,0BAA0B;AAAA,EAC1D;AAAA,EAET,YAAY,OAAe;AACzB,UAAM,uBAAuB,KAAK,EAAE;AACpC,SAAK,OAAO;AACZ,SAAK,QAAQ;AAAA,EACf;AACF;","names":[]}

package/dist/agent-session/store/assertCreateTurnThreadDelta.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pure createTurn thread-graph checks shared by all ISessionStore backends.
+ * Call after previous-turn thread ids are known; no DB I/O.
+ * Returns the resulting thread-id set (previous ∪ new_threads).
+ */
+export declare function assertCreateTurnThreadDelta(input: {
+    previousThreadIds: ReadonlySet<string>;
+    new_threads: readonly {
+        thread_id: string;
+    }[];
+    new_context_appends: readonly {
+        thread_id: string;
+    }[];
+    capability_states: readonly {
+        thread_id: string;
+    }[];
+}): Set<string>;
+//# sourceMappingURL=assertCreateTurnThreadDelta.d.ts.map

package/dist/agent-session/store/assertCreateTurnThreadDelta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertCreateTurnThreadDelta.d.ts","sourceRoot":"","sources":["../../../src/agent-session/store/assertCreateTurnThreadDelta.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,WAAW,EAAE,SAAS;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC9C,mBAAmB,EAAE,SAAS;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtD,iBAAiB,EAAE,SAAS;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACrD,GAAG,GAAG,CAAC,MAAM,CAAC,CAuCd"}

package/dist/agent-session/store/assertCreateTurnThreadDelta.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent-session/store/assertCreateTurnThreadDelta.ts
+var assertCreateTurnThreadDelta_exports = {};
+__export(assertCreateTurnThreadDelta_exports, {
+  assertCreateTurnThreadDelta: () => assertCreateTurnThreadDelta
+});
+module.exports = __toCommonJS(assertCreateTurnThreadDelta_exports);
+var import_SessionStoreErrors = require("./SessionStoreErrors.js");
+function assertCreateTurnThreadDelta(input) {
+  const newThreadIds = /* @__PURE__ */ new Set();
+  for (const nt of input.new_threads) {
+    if (input.previousThreadIds.has(nt.thread_id) || newThreadIds.has(nt.thread_id)) {
+      throw new import_SessionStoreErrors.SessionStoreInvariantError(
+        `new_threads must only contain threads absent on the previous turn; thread '${nt.thread_id}' already exists`
+      );
+    }
+    newThreadIds.add(nt.thread_id);
+  }
+  const knownThreadIds = new Set(input.previousThreadIds);
+  for (const threadId of newThreadIds) {
+    knownThreadIds.add(threadId);
+  }
+  for (const append of input.new_context_appends) {
+    if (!knownThreadIds.has(append.thread_id)) {
+      throw new import_SessionStoreErrors.SessionStoreInvariantError(`new_context_appends references unknown thread ${append.thread_id}`);
+    }
+  }
+  const seenCapabilityThreads = /* @__PURE__ */ new Set();
+  for (const capability of input.capability_states) {
+    if (!knownThreadIds.has(capability.thread_id)) {
+      throw new import_SessionStoreErrors.SessionStoreInvariantError(`capability_states references unknown thread ${capability.thread_id}`);
+    }
+    if (seenCapabilityThreads.has(capability.thread_id)) {
+      throw new import_SessionStoreErrors.SessionStoreInvariantError(`capability_states contains duplicate thread ${capability.thread_id}`);
+    }
+    seenCapabilityThreads.add(capability.thread_id);
+  }
+  for (const threadId of knownThreadIds) {
+    if (!seenCapabilityThreads.has(threadId)) {
+      throw new import_SessionStoreErrors.SessionStoreInvariantError(`capability_states is missing thread ${threadId}`);
+    }
+  }
+  return knownThreadIds;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertCreateTurnThreadDelta
+});
+//# sourceMappingURL=assertCreateTurnThreadDelta.js.map

package/dist/agent-session/store/assertCreateTurnThreadDelta.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agent-session/store/assertCreateTurnThreadDelta.ts"],"sourcesContent":["import { SessionStoreInvariantError } from './SessionStoreErrors';\n\n/**\n * Pure createTurn thread-graph checks shared by all ISessionStore backends.\n * Call after previous-turn thread ids are known; no DB I/O.\n * Returns the resulting thread-id set (previous ∪ new_threads).\n */\nexport function assertCreateTurnThreadDelta(input: {\n  previousThreadIds: ReadonlySet<string>;\n  new_threads: readonly { thread_id: string }[];\n  new_context_appends: readonly { thread_id: string }[];\n  capability_states: readonly { thread_id: string }[];\n}): Set<string> {\n  const newThreadIds = new Set<string>();\n  for (const nt of input.new_threads) {\n    if (input.previousThreadIds.has(nt.thread_id) || newThreadIds.has(nt.thread_id)) {\n      throw new SessionStoreInvariantError(\n        `new_threads must only contain threads absent on the previous turn; thread '${nt.thread_id}' already exists`,\n      );\n    }\n    newThreadIds.add(nt.thread_id);\n  }\n\n  const knownThreadIds = new Set(input.previousThreadIds);\n  for (const threadId of newThreadIds) {\n    knownThreadIds.add(threadId);\n  }\n\n  for (const append of input.new_context_appends) {\n    if (!knownThreadIds.has(append.thread_id)) {\n      throw new SessionStoreInvariantError(`new_context_appends references unknown thread ${append.thread_id}`);\n    }\n  }\n\n  const seenCapabilityThreads = new Set<string>();\n  for (const capability of input.capability_states) {\n    if (!knownThreadIds.has(capability.thread_id)) {\n      throw new SessionStoreInvariantError(`capability_states references unknown thread ${capability.thread_id}`);\n    }\n    if (seenCapabilityThreads.has(capability.thread_id)) {\n      throw new SessionStoreInvariantError(`capability_states contains duplicate thread ${capability.thread_id}`);\n    }\n    seenCapabilityThreads.add(capability.thread_id);\n  }\n  for (const threadId of knownThreadIds) {\n    if (!seenCapabilityThreads.has(threadId)) {\n      throw new SessionStoreInvariantError(`capability_states is missing thread ${threadId}`);\n    }\n  }\n\n  return knownThreadIds;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCAA2C;AAOpC,SAAS,4BAA4B,OAK5B;AACd,QAAM,eAAe,oBAAI,IAAY;AACrC,aAAW,MAAM,MAAM,aAAa;AAClC,QAAI,MAAM,kBAAkB,IAAI,GAAG,SAAS,KAAK,aAAa,IAAI,GAAG,SAAS,GAAG;AAC/E,YAAM,IAAI;AAAA,QACR,8EAA8E,GAAG,SAAS;AAAA,MAC5F;AAAA,IACF;AACA,iBAAa,IAAI,GAAG,SAAS;AAAA,EAC/B;AAEA,QAAM,iBAAiB,IAAI,IAAI,MAAM,iBAAiB;AACtD,aAAW,YAAY,cAAc;AACnC,mBAAe,IAAI,QAAQ;AAAA,EAC7B;AAEA,aAAW,UAAU,MAAM,qBAAqB;AAC9C,QAAI,CAAC,eAAe,IAAI,OAAO,SAAS,GAAG;AACzC,YAAM,IAAI,qDAA2B,iDAAiD,OAAO,SAAS,EAAE;AAAA,IAC1G;AAAA,EACF;AAEA,QAAM,wBAAwB,oBAAI,IAAY;AAC9C,aAAW,cAAc,MAAM,mBAAmB;AAChD,QAAI,CAAC,eAAe,IAAI,WAAW,SAAS,GAAG;AAC7C,YAAM,IAAI,qDAA2B,+CAA+C,WAAW,SAAS,EAAE;AAAA,IAC5G;AACA,QAAI,sBAAsB,IAAI,WAAW,SAAS,GAAG;AACnD,YAAM,IAAI,qDAA2B,+CAA+C,WAAW,SAAS,EAAE;AAAA,IAC5G;AACA,0BAAsB,IAAI,WAAW,SAAS;AAAA,EAChD;AACA,aAAW,YAAY,gBAAgB;AACrC,QAAI,CAAC,sBAAsB,IAAI,QAAQ,GAAG;AACxC,YAAM,IAAI,qDAA2B,uCAAuC,QAAQ,EAAE;AAAA,IACxF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/agent-session/store/assertCreateTurnThreadDelta.mjs

@@ -0,0 +1,42 @@
+// src/agent-session/store/assertCreateTurnThreadDelta.ts
+import { SessionStoreInvariantError } from "./SessionStoreErrors.mjs";
+function assertCreateTurnThreadDelta(input) {
+  const newThreadIds = /* @__PURE__ */ new Set();
+  for (const nt of input.new_threads) {
+    if (input.previousThreadIds.has(nt.thread_id) || newThreadIds.has(nt.thread_id)) {
+      throw new SessionStoreInvariantError(
+        `new_threads must only contain threads absent on the previous turn; thread '${nt.thread_id}' already exists`
+      );
+    }
+    newThreadIds.add(nt.thread_id);
+  }
+  const knownThreadIds = new Set(input.previousThreadIds);
+  for (const threadId of newThreadIds) {
+    knownThreadIds.add(threadId);
+  }
+  for (const append of input.new_context_appends) {
+    if (!knownThreadIds.has(append.thread_id)) {
+      throw new SessionStoreInvariantError(`new_context_appends references unknown thread ${append.thread_id}`);
+    }
+  }
+  const seenCapabilityThreads = /* @__PURE__ */ new Set();
+  for (const capability of input.capability_states) {
+    if (!knownThreadIds.has(capability.thread_id)) {
+      throw new SessionStoreInvariantError(`capability_states references unknown thread ${capability.thread_id}`);
+    }
+    if (seenCapabilityThreads.has(capability.thread_id)) {
+      throw new SessionStoreInvariantError(`capability_states contains duplicate thread ${capability.thread_id}`);
+    }
+    seenCapabilityThreads.add(capability.thread_id);
+  }
+  for (const threadId of knownThreadIds) {
+    if (!seenCapabilityThreads.has(threadId)) {
+      throw new SessionStoreInvariantError(`capability_states is missing thread ${threadId}`);
+    }
+  }
+  return knownThreadIds;
+}
+export {
+  assertCreateTurnThreadDelta
+};
+//# sourceMappingURL=assertCreateTurnThreadDelta.mjs.map

package/dist/agent-session/store/assertCreateTurnThreadDelta.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agent-session/store/assertCreateTurnThreadDelta.ts"],"sourcesContent":["import { SessionStoreInvariantError } from './SessionStoreErrors';\n\n/**\n * Pure createTurn thread-graph checks shared by all ISessionStore backends.\n * Call after previous-turn thread ids are known; no DB I/O.\n * Returns the resulting thread-id set (previous ∪ new_threads).\n */\nexport function assertCreateTurnThreadDelta(input: {\n  previousThreadIds: ReadonlySet<string>;\n  new_threads: readonly { thread_id: string }[];\n  new_context_appends: readonly { thread_id: string }[];\n  capability_states: readonly { thread_id: string }[];\n}): Set<string> {\n  const newThreadIds = new Set<string>();\n  for (const nt of input.new_threads) {\n    if (input.previousThreadIds.has(nt.thread_id) || newThreadIds.has(nt.thread_id)) {\n      throw new SessionStoreInvariantError(\n        `new_threads must only contain threads absent on the previous turn; thread '${nt.thread_id}' already exists`,\n      );\n    }\n    newThreadIds.add(nt.thread_id);\n  }\n\n  const knownThreadIds = new Set(input.previousThreadIds);\n  for (const threadId of newThreadIds) {\n    knownThreadIds.add(threadId);\n  }\n\n  for (const append of input.new_context_appends) {\n    if (!knownThreadIds.has(append.thread_id)) {\n      throw new SessionStoreInvariantError(`new_context_appends references unknown thread ${append.thread_id}`);\n    }\n  }\n\n  const seenCapabilityThreads = new Set<string>();\n  for (const capability of input.capability_states) {\n    if (!knownThreadIds.has(capability.thread_id)) {\n      throw new SessionStoreInvariantError(`capability_states references unknown thread ${capability.thread_id}`);\n    }\n    if (seenCapabilityThreads.has(capability.thread_id)) {\n      throw new SessionStoreInvariantError(`capability_states contains duplicate thread ${capability.thread_id}`);\n    }\n    seenCapabilityThreads.add(capability.thread_id);\n  }\n  for (const threadId of knownThreadIds) {\n    if (!seenCapabilityThreads.has(threadId)) {\n      throw new SessionStoreInvariantError(`capability_states is missing thread ${threadId}`);\n    }\n  }\n\n  return knownThreadIds;\n}\n"],"mappings":";AAAA,SAAS,kCAAkC;AAOpC,SAAS,4BAA4B,OAK5B;AACd,QAAM,eAAe,oBAAI,IAAY;AACrC,aAAW,MAAM,MAAM,aAAa;AAClC,QAAI,MAAM,kBAAkB,IAAI,GAAG,SAAS,KAAK,aAAa,IAAI,GAAG,SAAS,GAAG;AAC/E,YAAM,IAAI;AAAA,QACR,8EAA8E,GAAG,SAAS;AAAA,MAC5F;AAAA,IACF;AACA,iBAAa,IAAI,GAAG,SAAS;AAAA,EAC/B;AAEA,QAAM,iBAAiB,IAAI,IAAI,MAAM,iBAAiB;AACtD,aAAW,YAAY,cAAc;AACnC,mBAAe,IAAI,QAAQ;AAAA,EAC7B;AAEA,aAAW,UAAU,MAAM,qBAAqB;AAC9C,QAAI,CAAC,eAAe,IAAI,OAAO,SAAS,GAAG;AACzC,YAAM,IAAI,2BAA2B,iDAAiD,OAAO,SAAS,EAAE;AAAA,IAC1G;AAAA,EACF;AAEA,QAAM,wBAAwB,oBAAI,IAAY;AAC9C,aAAW,cAAc,MAAM,mBAAmB;AAChD,QAAI,CAAC,eAAe,IAAI,WAAW,SAAS,GAAG;AAC7C,YAAM,IAAI,2BAA2B,+CAA+C,WAAW,SAAS,EAAE;AAAA,IAC5G;AACA,QAAI,sBAAsB,IAAI,WAAW,SAAS,GAAG;AACnD,YAAM,IAAI,2BAA2B,+CAA+C,WAAW,SAAS,EAAE;AAAA,IAC5G;AACA,0BAAsB,IAAI,WAAW,SAAS;AAAA,EAChD;AACA,aAAW,YAAY,gBAAgB;AACrC,QAAI,CAAC,sBAAsB,IAAI,QAAQ,GAAG;AACxC,YAAM,IAAI,2BAA2B,uCAAuC,QAAQ,EAAE;AAAA,IACxF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/core/InstructionBuilder.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Builds a structured XML system prompt as a tree of named sections.
+ *
+ * Each node is an XML section (e.g. `<sandbox>`) that can contain
+ * plain text and/or nested sections. Children are always rendered
+ * in insertion order.
+ *
+ * @example
+ * // Creating nested and sibling sections:
+ *
+ * const root = InstructionBuilder.createSystemPrompt(ROOT_AGENT_IDENTITY);
+ *
+ * // Add a leaf section (tag + text, no further nesting)
+ * root.addSection('rules', 'Follow these rules...');
+ *
+ * // Add raw text without a wrapping tag
+ * root.addContent('Some standalone text');
+ *
+ * // Begin a section you want to nest into — returns the child builder
+ * const capabilities = root.beginSection('capabilities');
+ * capabilities.addSection('tool-a', 'Tool A instructions');
+ * capabilities.addSection('tool-b', 'Tool B instructions');
+ *
+ * // Nest deeper — beginSection on a child
+ * const sandbox = capabilities.beginSection('sandbox');
+ * sandbox.addContent('Sandbox overview');
+ * sandbox.addSection('skill', 'Skill details');
+ *
+ * // Back to root level — just use the root reference again
+ * root.addSection('user-instructions', userInput, true); // escapeContent = true
+ *
+ * console.log(root.build());
+ *
+ * // Output:
+ * // <system-prompt>
+ * //   <agent-identity>...</agent-identity>
+ * //   <rules>Follow these rules...</rules>
+ * //   Some standalone text
+ * //   <capabilities>
+ * //     <tool-a>Tool A instructions</tool-a>
+ * //     <tool-b>Tool B instructions</tool-b>
+ * //     <sandbox>
+ * //       Sandbox overview
+ * //       <skill>Skill details</skill>
+ * //     </sandbox>
+ * //   </capabilities>
+ * //   <user-instructions><![CDATA[...]]></user-instructions>
+ * // </system-prompt>
+ */
+export declare const ROOT_AGENT_IDENTITY = "You are the Agent, an AI assistant that helps users accomplish tasks by leveraging available tools and capabilities.";
+export declare class InstructionBuilder {
+    /** The XML tag name for this section node. */
+    private currentTag;
+    private escapeContent;
+    private children;
+    constructor(currentTag: string, escapeContent?: boolean);
+    /** Creates the root `<system-prompt>` node with the given identity in `<agent-identity>`. */
+    static createSystemPrompt(identity: string): InstructionBuilder;
+    /** Adds raw text (no wrapping tag) to this section. Empty strings are ignored. */
+    addContent(content: string): this;
+    /**
+     * Adds a leaf section: `<tag>content</tag>`. Empty content is ignored.
+     * Set escapeContent = true to wrap content in CDATA (for arbitrary/untrusted text).
+     */
+    addSection(tag: string, content: string, escapeContent?: boolean): this;
+    /** Creates a nested section and returns it so you can add children to it. */
+    beginSection(tag: string): InstructionBuilder;
+    /** Recursively renders the tree into an XML string. Empty sections are skipped. */
+    build(): string;
+}
+//# sourceMappingURL=InstructionBuilder.d.ts.map

package/dist/core/InstructionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstructionBuilder.d.ts","sourceRoot":"","sources":["../../src/core/InstructionBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,eAAO,MAAM,mBAAmB,yHACwF,CAAC;AAEzH,qBAAa,kBAAkB;IAC7B,8CAA8C;IAC9C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAuC;IAEvD,YAAY,UAAU,EAAE,MAAM,EAAE,aAAa,UAAQ,EAGpD;IAED,6FAA6F;IAC7F,MAAM,CAAC,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CAI9D;IAED,kFAAkF;IAClF,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAIhC;IAED;;;OAGG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,UAAQ,GAAG,IAAI,CAOpE;IAED,6EAA6E;IAC7E,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAI5C;IAED,mFAAmF;IACnF,KAAK,IAAI,MAAM,CAkBd;CACF"}

package/dist/core/InstructionBuilder.js

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/InstructionBuilder.ts
+var InstructionBuilder_exports = {};
+__export(InstructionBuilder_exports, {
+  InstructionBuilder: () => InstructionBuilder,
+  ROOT_AGENT_IDENTITY: () => ROOT_AGENT_IDENTITY
+});
+module.exports = __toCommonJS(InstructionBuilder_exports);
+var ROOT_AGENT_IDENTITY = "You are the Agent, an AI assistant that helps users accomplish tasks by leveraging available tools and capabilities.";
+var InstructionBuilder = class _InstructionBuilder {
+  /** The XML tag name for this section node. */
+  currentTag;
+  escapeContent;
+  children = [];
+  constructor(currentTag, escapeContent = false) {
+    this.currentTag = currentTag;
+    this.escapeContent = escapeContent;
+  }
+  /** Creates the root `<system-prompt>` node with the given identity in `<agent-identity>`. */
+  static createSystemPrompt(identity) {
+    const builder = new _InstructionBuilder("system-prompt");
+    builder.addSection("agent-identity", identity);
+    return builder;
+  }
+  /** Adds raw text (no wrapping tag) to this section. Empty strings are ignored. */
+  addContent(content) {
+    const trimmed = content.trim();
+    if (trimmed) this.children.push(trimmed);
+    return this;
+  }
+  /**
+   * Adds a leaf section: `<tag>content</tag>`. Empty content is ignored.
+   * Set escapeContent = true to wrap content in CDATA (for arbitrary/untrusted text).
+   */
+  addSection(tag, content, escapeContent = false) {
+    const trimmed = content.trim();
+    if (!trimmed) return this;
+    const child = new _InstructionBuilder(tag, escapeContent);
+    child.children.push(trimmed);
+    this.children.push(child);
+    return this;
+  }
+  /** Creates a nested section and returns it so you can add children to it. */
+  beginSection(tag) {
+    const child = new _InstructionBuilder(tag);
+    this.children.push(child);
+    return child;
+  }
+  /** Recursively renders the tree into an XML string. Empty sections are skipped. */
+  build() {
+    const inner = [];
+    for (const child of this.children) {
+      if (typeof child === "string") {
+        inner.push(child);
+      } else {
+        const output = child.build();
+        if (output) inner.push(output);
+      }
+    }
+    if (inner.length === 0) return "";
+    const body = inner.join("\n\n");
+    if (this.escapeContent) {
+      return `<${this.currentTag}><![CDATA[
+${body}
+]]></${this.currentTag}>`;
+    }
+    return `<${this.currentTag}>
+${body}
+</${this.currentTag}>`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InstructionBuilder,
+  ROOT_AGENT_IDENTITY
+});
+//# sourceMappingURL=InstructionBuilder.js.map

package/dist/core/InstructionBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/InstructionBuilder.ts"],"sourcesContent":["/**\n * Builds a structured XML system prompt as a tree of named sections.\n *\n * Each node is an XML section (e.g. `<sandbox>`) that can contain\n * plain text and/or nested sections. Children are always rendered\n * in insertion order.\n *\n * @example\n * // Creating nested and sibling sections:\n *\n * const root = InstructionBuilder.createSystemPrompt(ROOT_AGENT_IDENTITY);\n *\n * // Add a leaf section (tag + text, no further nesting)\n * root.addSection('rules', 'Follow these rules...');\n *\n * // Add raw text without a wrapping tag\n * root.addContent('Some standalone text');\n *\n * // Begin a section you want to nest into — returns the child builder\n * const capabilities = root.beginSection('capabilities');\n * capabilities.addSection('tool-a', 'Tool A instructions');\n * capabilities.addSection('tool-b', 'Tool B instructions');\n *\n * // Nest deeper — beginSection on a child\n * const sandbox = capabilities.beginSection('sandbox');\n * sandbox.addContent('Sandbox overview');\n * sandbox.addSection('skill', 'Skill details');\n *\n * // Back to root level — just use the root reference again\n * root.addSection('user-instructions', userInput, true); // escapeContent = true\n *\n * console.log(root.build());\n *\n * // Output:\n * // <system-prompt>\n * //   <agent-identity>...</agent-identity>\n * //   <rules>Follow these rules...</rules>\n * //   Some standalone text\n * //   <capabilities>\n * //     <tool-a>Tool A instructions</tool-a>\n * //     <tool-b>Tool B instructions</tool-b>\n * //     <sandbox>\n * //       Sandbox overview\n * //       <skill>Skill details</skill>\n * //     </sandbox>\n * //   </capabilities>\n * //   <user-instructions><![CDATA[...]]></user-instructions>\n * // </system-prompt>\n */\n\nexport const ROOT_AGENT_IDENTITY =\n  'You are the Agent, an AI assistant that helps users accomplish tasks by leveraging available tools and capabilities.';\n\nexport class InstructionBuilder {\n  /** The XML tag name for this section node. */\n  private currentTag: string;\n  private escapeContent: boolean;\n  private children: (string | InstructionBuilder)[] = [];\n\n  constructor(currentTag: string, escapeContent = false) {\n    this.currentTag = currentTag;\n    this.escapeContent = escapeContent;\n  }\n\n  /** Creates the root `<system-prompt>` node with the given identity in `<agent-identity>`. */\n  static createSystemPrompt(identity: string): InstructionBuilder {\n    const builder = new InstructionBuilder('system-prompt');\n    builder.addSection('agent-identity', identity);\n    return builder;\n  }\n\n  /** Adds raw text (no wrapping tag) to this section. Empty strings are ignored. */\n  addContent(content: string): this {\n    const trimmed = content.trim();\n    if (trimmed) this.children.push(trimmed);\n    return this;\n  }\n\n  /**\n   * Adds a leaf section: `<tag>content</tag>`. Empty content is ignored.\n   * Set escapeContent = true to wrap content in CDATA (for arbitrary/untrusted text).\n   */\n  addSection(tag: string, content: string, escapeContent = false): this {\n    const trimmed = content.trim();\n    if (!trimmed) return this;\n    const child = new InstructionBuilder(tag, escapeContent);\n    child.children.push(trimmed);\n    this.children.push(child);\n    return this;\n  }\n\n  /** Creates a nested section and returns it so you can add children to it. */\n  beginSection(tag: string): InstructionBuilder {\n    const child = new InstructionBuilder(tag);\n    this.children.push(child);\n    return child;\n  }\n\n  /** Recursively renders the tree into an XML string. Empty sections are skipped. */\n  build(): string {\n    const inner: string[] = [];\n    for (const child of this.children) {\n      if (typeof child === 'string') {\n        inner.push(child);\n      } else {\n        const output = child.build();\n        if (output) inner.push(output);\n      }\n    }\n\n    if (inner.length === 0) return '';\n\n    const body = inner.join('\\n\\n');\n    if (this.escapeContent) {\n      return `<${this.currentTag}><![CDATA[\\n${body}\\n]]></${this.currentTag}>`;\n    }\n    return `<${this.currentTag}>\\n${body}\\n</${this.currentTag}>`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkDO,IAAM,sBACX;AAEK,IAAM,qBAAN,MAAM,oBAAmB;AAAA;AAAA,EAEtB;AAAA,EACA;AAAA,EACA,WAA4C,CAAC;AAAA,EAErD,YAAY,YAAoB,gBAAgB,OAAO;AACrD,SAAK,aAAa;AAClB,SAAK,gBAAgB;AAAA,EACvB;AAAA;AAAA,EAGA,OAAO,mBAAmB,UAAsC;AAC9D,UAAM,UAAU,IAAI,oBAAmB,eAAe;AACtD,YAAQ,WAAW,kBAAkB,QAAQ;AAC7C,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,WAAW,SAAuB;AAChC,UAAM,UAAU,QAAQ,KAAK;AAC7B,QAAI,QAAS,MAAK,SAAS,KAAK,OAAO;AACvC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAW,KAAa,SAAiB,gBAAgB,OAAa;AACpE,UAAM,UAAU,QAAQ,KAAK;AAC7B,QAAI,CAAC,QAAS,QAAO;AACrB,UAAM,QAAQ,IAAI,oBAAmB,KAAK,aAAa;AACvD,UAAM,SAAS,KAAK,OAAO;AAC3B,SAAK,SAAS,KAAK,KAAK;AACxB,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,aAAa,KAAiC;AAC5C,UAAM,QAAQ,IAAI,oBAAmB,GAAG;AACxC,SAAK,SAAS,KAAK,KAAK;AACxB,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,QAAgB;AACd,UAAM,QAAkB,CAAC;AACzB,eAAW,SAAS,KAAK,UAAU;AACjC,UAAI,OAAO,UAAU,UAAU;AAC7B,cAAM,KAAK,KAAK;AAAA,MAClB,OAAO;AACL,cAAM,SAAS,MAAM,MAAM;AAC3B,YAAI,OAAQ,OAAM,KAAK,MAAM;AAAA,MAC/B;AAAA,IACF;AAEA,QAAI,MAAM,WAAW,EAAG,QAAO;AAE/B,UAAM,OAAO,MAAM,KAAK,MAAM;AAC9B,QAAI,KAAK,eAAe;AACtB,aAAO,IAAI,KAAK,UAAU;AAAA,EAAe,IAAI;AAAA,OAAU,KAAK,UAAU;AAAA,IACxE;AACA,WAAO,IAAI,KAAK,UAAU;AAAA,EAAM,IAAI;AAAA,IAAO,KAAK,UAAU;AAAA,EAC5D;AACF;","names":[]}

package/dist/core/InstructionBuilder.mjs

@@ -0,0 +1,69 @@
+// src/core/InstructionBuilder.ts
+var ROOT_AGENT_IDENTITY = "You are the Agent, an AI assistant that helps users accomplish tasks by leveraging available tools and capabilities.";
+var InstructionBuilder = class _InstructionBuilder {
+  /** The XML tag name for this section node. */
+  currentTag;
+  escapeContent;
+  children = [];
+  constructor(currentTag, escapeContent = false) {
+    this.currentTag = currentTag;
+    this.escapeContent = escapeContent;
+  }
+  /** Creates the root `<system-prompt>` node with the given identity in `<agent-identity>`. */
+  static createSystemPrompt(identity) {
+    const builder = new _InstructionBuilder("system-prompt");
+    builder.addSection("agent-identity", identity);
+    return builder;
+  }
+  /** Adds raw text (no wrapping tag) to this section. Empty strings are ignored. */
+  addContent(content) {
+    const trimmed = content.trim();
+    if (trimmed) this.children.push(trimmed);
+    return this;
+  }
+  /**
+   * Adds a leaf section: `<tag>content</tag>`. Empty content is ignored.
+   * Set escapeContent = true to wrap content in CDATA (for arbitrary/untrusted text).
+   */
+  addSection(tag, content, escapeContent = false) {
+    const trimmed = content.trim();
+    if (!trimmed) return this;
+    const child = new _InstructionBuilder(tag, escapeContent);
+    child.children.push(trimmed);
+    this.children.push(child);
+    return this;
+  }
+  /** Creates a nested section and returns it so you can add children to it. */
+  beginSection(tag) {
+    const child = new _InstructionBuilder(tag);
+    this.children.push(child);
+    return child;
+  }
+  /** Recursively renders the tree into an XML string. Empty sections are skipped. */
+  build() {
+    const inner = [];
+    for (const child of this.children) {
+      if (typeof child === "string") {
+        inner.push(child);
+      } else {
+        const output = child.build();
+        if (output) inner.push(output);
+      }
+    }
+    if (inner.length === 0) return "";
+    const body = inner.join("\n\n");
+    if (this.escapeContent) {
+      return `<${this.currentTag}><![CDATA[
+${body}
+]]></${this.currentTag}>`;
+    }
+    return `<${this.currentTag}>
+${body}
+</${this.currentTag}>`;
+  }
+};
+export {
+  InstructionBuilder,
+  ROOT_AGENT_IDENTITY
+};
+//# sourceMappingURL=InstructionBuilder.mjs.map

package/dist/core/InstructionBuilder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/InstructionBuilder.ts"],"sourcesContent":["/**\n * Builds a structured XML system prompt as a tree of named sections.\n *\n * Each node is an XML section (e.g. `<sandbox>`) that can contain\n * plain text and/or nested sections. Children are always rendered\n * in insertion order.\n *\n * @example\n * // Creating nested and sibling sections:\n *\n * const root = InstructionBuilder.createSystemPrompt(ROOT_AGENT_IDENTITY);\n *\n * // Add a leaf section (tag + text, no further nesting)\n * root.addSection('rules', 'Follow these rules...');\n *\n * // Add raw text without a wrapping tag\n * root.addContent('Some standalone text');\n *\n * // Begin a section you want to nest into — returns the child builder\n * const capabilities = root.beginSection('capabilities');\n * capabilities.addSection('tool-a', 'Tool A instructions');\n * capabilities.addSection('tool-b', 'Tool B instructions');\n *\n * // Nest deeper — beginSection on a child\n * const sandbox = capabilities.beginSection('sandbox');\n * sandbox.addContent('Sandbox overview');\n * sandbox.addSection('skill', 'Skill details');\n *\n * // Back to root level — just use the root reference again\n * root.addSection('user-instructions', userInput, true); // escapeContent = true\n *\n * console.log(root.build());\n *\n * // Output:\n * // <system-prompt>\n * //   <agent-identity>...</agent-identity>\n * //   <rules>Follow these rules...</rules>\n * //   Some standalone text\n * //   <capabilities>\n * //     <tool-a>Tool A instructions</tool-a>\n * //     <tool-b>Tool B instructions</tool-b>\n * //     <sandbox>\n * //       Sandbox overview\n * //       <skill>Skill details</skill>\n * //     </sandbox>\n * //   </capabilities>\n * //   <user-instructions><![CDATA[...]]></user-instructions>\n * // </system-prompt>\n */\n\nexport const ROOT_AGENT_IDENTITY =\n  'You are the Agent, an AI assistant that helps users accomplish tasks by leveraging available tools and capabilities.';\n\nexport class InstructionBuilder {\n  /** The XML tag name for this section node. */\n  private currentTag: string;\n  private escapeContent: boolean;\n  private children: (string | InstructionBuilder)[] = [];\n\n  constructor(currentTag: string, escapeContent = false) {\n    this.currentTag = currentTag;\n    this.escapeContent = escapeContent;\n  }\n\n  /** Creates the root `<system-prompt>` node with the given identity in `<agent-identity>`. */\n  static createSystemPrompt(identity: string): InstructionBuilder {\n    const builder = new InstructionBuilder('system-prompt');\n    builder.addSection('agent-identity', identity);\n    return builder;\n  }\n\n  /** Adds raw text (no wrapping tag) to this section. Empty strings are ignored. */\n  addContent(content: string): this {\n    const trimmed = content.trim();\n    if (trimmed) this.children.push(trimmed);\n    return this;\n  }\n\n  /**\n   * Adds a leaf section: `<tag>content</tag>`. Empty content is ignored.\n   * Set escapeContent = true to wrap content in CDATA (for arbitrary/untrusted text).\n   */\n  addSection(tag: string, content: string, escapeContent = false): this {\n    const trimmed = content.trim();\n    if (!trimmed) return this;\n    const child = new InstructionBuilder(tag, escapeContent);\n    child.children.push(trimmed);\n    this.children.push(child);\n    return this;\n  }\n\n  /** Creates a nested section and returns it so you can add children to it. */\n  beginSection(tag: string): InstructionBuilder {\n    const child = new InstructionBuilder(tag);\n    this.children.push(child);\n    return child;\n  }\n\n  /** Recursively renders the tree into an XML string. Empty sections are skipped. */\n  build(): string {\n    const inner: string[] = [];\n    for (const child of this.children) {\n      if (typeof child === 'string') {\n        inner.push(child);\n      } else {\n        const output = child.build();\n        if (output) inner.push(output);\n      }\n    }\n\n    if (inner.length === 0) return '';\n\n    const body = inner.join('\\n\\n');\n    if (this.escapeContent) {\n      return `<${this.currentTag}><![CDATA[\\n${body}\\n]]></${this.currentTag}>`;\n    }\n    return `<${this.currentTag}>\\n${body}\\n</${this.currentTag}>`;\n  }\n}\n"],"mappings":";AAkDO,IAAM,sBACX;AAEK,IAAM,qBAAN,MAAM,oBAAmB;AAAA;AAAA,EAEtB;AAAA,EACA;AAAA,EACA,WAA4C,CAAC;AAAA,EAErD,YAAY,YAAoB,gBAAgB,OAAO;AACrD,SAAK,aAAa;AAClB,SAAK,gBAAgB;AAAA,EACvB;AAAA;AAAA,EAGA,OAAO,mBAAmB,UAAsC;AAC9D,UAAM,UAAU,IAAI,oBAAmB,eAAe;AACtD,YAAQ,WAAW,kBAAkB,QAAQ;AAC7C,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,WAAW,SAAuB;AAChC,UAAM,UAAU,QAAQ,KAAK;AAC7B,QAAI,QAAS,MAAK,SAAS,KAAK,OAAO;AACvC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAW,KAAa,SAAiB,gBAAgB,OAAa;AACpE,UAAM,UAAU,QAAQ,KAAK;AAC7B,QAAI,CAAC,QAAS,QAAO;AACrB,UAAM,QAAQ,IAAI,oBAAmB,KAAK,aAAa;AACvD,UAAM,SAAS,KAAK,OAAO;AAC3B,SAAK,SAAS,KAAK,KAAK;AACxB,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,aAAa,KAAiC;AAC5C,UAAM,QAAQ,IAAI,oBAAmB,GAAG;AACxC,SAAK,SAAS,KAAK,KAAK;AACxB,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,QAAgB;AACd,UAAM,QAAkB,CAAC;AACzB,eAAW,SAAS,KAAK,UAAU;AACjC,UAAI,OAAO,UAAU,UAAU;AAC7B,cAAM,KAAK,KAAK;AAAA,MAClB,OAAO;AACL,cAAM,SAAS,MAAM,MAAM;AAC3B,YAAI,OAAQ,OAAM,KAAK,MAAM;AAAA,MAC/B;AAAA,IACF;AAEA,QAAI,MAAM,WAAW,EAAG,QAAO;AAE/B,UAAM,OAAO,MAAM,KAAK,MAAM;AAC9B,QAAI,KAAK,eAAe;AACtB,aAAO,IAAI,KAAK,UAAU;AAAA,EAAe,IAAI;AAAA,OAAU,KAAK,UAAU;AAAA,IACxE;AACA,WAAO,IAAI,KAAK,UAAU;AAAA,EAAM,IAAI;AAAA,IAAO,KAAK,UAAU;AAAA,EAC5D;AACF;","names":[]}

package/dist/core/capabilities/AgentCapability.d.ts

@@ -0,0 +1,32 @@
+import type { InstructionBuilder } from '../InstructionBuilder';
+import type { IToolSet } from '../mcp/IMCPServer';
+import type { PostToolCallAgentContextProcessor, PreLLMAgentContextProcessor, PreLLMEphemeralAgentContextProcessor, PreSendContextProcessor } from './AgentContextProcessor';
+import type { ToolResponseProcessor } from './ToolResponseProcessor';
+/**
+ * JSON-serializable value. Excludes `undefined` — durability is jsonb/JSON, so
+ * clears use `null` and absent data omits the key or the map.
+ */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** Cross-turn capability KV map. Keys: capability.state.key; `tfy.` reserved for builtins. */
+export type CapabilityState = Record<string, JsonValue>;
+export interface AgentCapability {
+    readonly systemToolSets?: readonly IToolSet[] | undefined;
+    readonly preSendProcessors?: readonly PreSendContextProcessor[] | undefined;
+    readonly preLLMProcessors?: readonly PreLLMAgentContextProcessor[] | undefined;
+    readonly preLLMEphemeralProcessors?: readonly PreLLMEphemeralAgentContextProcessor[] | undefined;
+    readonly postToolCallProcessors?: readonly PostToolCallAgentContextProcessor[] | undefined;
+    readonly toolResponseProcessors?: readonly ToolResponseProcessor[] | undefined;
+    readonly instructionBuilders?: readonly ((builder: InstructionBuilder) => void)[] | undefined;
+    /**
+     * Cross-turn durable state. `key` must be unique across capabilities on a
+     * thread (`tfy.` reserved for builtins). `load` hydrates from the previous
+     * turn's capability_state; writes go through CAPABILITY_STATE events.
+     */
+    readonly state?: {
+        key: string;
+        load(state: JsonValue): void;
+    };
+}
+//# sourceMappingURL=AgentCapability.d.ts.map

package/dist/core/capabilities/AgentCapability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentCapability.d.ts","sourceRoot":"","sources":["../../../src/core/capabilities/AgentCapability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EACV,iCAAiC,EACjC,2BAA2B,EAC3B,oCAAoC,EACpC,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAErE;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEtG,8FAA8F;AAC9F,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAExD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,QAAQ,EAAE,GAAG,SAAS,CAAC;IAC1D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,uBAAuB,EAAE,GAAG,SAAS,CAAC;IAC5E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,2BAA2B,EAAE,GAAG,SAAS,CAAC;IAC/E,QAAQ,CAAC,yBAAyB,CAAC,EAAE,SAAS,oCAAoC,EAAE,GAAG,SAAS,CAAC;IACjG,QAAQ,CAAC,sBAAsB,CAAC,EAAE,SAAS,iCAAiC,EAAE,GAAG,SAAS,CAAC;IAC3F,QAAQ,CAAC,sBAAsB,CAAC,EAAE,SAAS,qBAAqB,EAAE,GAAG,SAAS,CAAC;IAC/E,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,CAAC,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAC,EAAE,GAAG,SAAS,CAAC;IAC9F;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;KAAE,CAAC;CAChE"}

package/dist/core/capabilities/AgentCapability.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/capabilities/AgentCapability.ts
+var AgentCapability_exports = {};
+module.exports = __toCommonJS(AgentCapability_exports);
+//# sourceMappingURL=AgentCapability.js.map

package/dist/core/capabilities/AgentCapability.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/capabilities/AgentCapability.ts"],"sourcesContent":["import type { InstructionBuilder } from '../InstructionBuilder';\nimport type { IToolSet } from '../mcp/IMCPServer';\nimport type {\n  PostToolCallAgentContextProcessor,\n  PreLLMAgentContextProcessor,\n  PreLLMEphemeralAgentContextProcessor,\n  PreSendContextProcessor,\n} from './AgentContextProcessor';\nimport type { ToolResponseProcessor } from './ToolResponseProcessor';\n\n/**\n * JSON-serializable value. Excludes `undefined` — durability is jsonb/JSON, so\n * clears use `null` and absent data omits the key or the map.\n */\nexport type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };\n\n/** Cross-turn capability KV map. Keys: capability.state.key; `tfy.` reserved for builtins. */\nexport type CapabilityState = Record<string, JsonValue>;\n\nexport interface AgentCapability {\n  readonly systemToolSets?: readonly IToolSet[] | undefined;\n  readonly preSendProcessors?: readonly PreSendContextProcessor[] | undefined;\n  readonly preLLMProcessors?: readonly PreLLMAgentContextProcessor[] | undefined;\n  readonly preLLMEphemeralProcessors?: readonly PreLLMEphemeralAgentContextProcessor[] | undefined;\n  readonly postToolCallProcessors?: readonly PostToolCallAgentContextProcessor[] | undefined;\n  readonly toolResponseProcessors?: readonly ToolResponseProcessor[] | undefined;\n  readonly instructionBuilders?: readonly ((builder: InstructionBuilder) => void)[] | undefined;\n  /**\n   * Cross-turn durable state. `key` must be unique across capabilities on a\n   * thread (`tfy.` reserved for builtins). `load` hydrates from the previous\n   * turn's capability_state; writes go through CAPABILITY_STATE events.\n   */\n  readonly state?: { key: string; load(state: JsonValue): void };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/core/capabilities/AgentCapability.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=AgentCapability.mjs.map

package/dist/core/capabilities/AgentCapability.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/core/capabilities/AgentContextProcessor.d.ts

@@ -0,0 +1,30 @@
+import type { ChatCompletionMessageParam } from 'openai/resources/chat';
+import type { ThreadOverwriteContextEvent } from '../events/schema';
+import type { AgentThreadAppendContext, ContextMessage, InternalCapabilityStateEvent, InternalPassthroughEvent } from '../runtime/AgentThread.types';
+import type { CurrentContextUsage } from '../runtime/contextUsage';
+import type { Sandbox } from '../sandbox/Sandbox';
+/** Ambient thread snapshot passed Readonly to every capability processor hook. */
+export interface AgentThreadExecutionContext {
+    threadId: string;
+    sandbox?: Sandbox | undefined;
+    currentContextUsage: CurrentContextUsage;
+    context: ContextMessage[];
+}
+export type AgentContextProcessorOverwriteContext = Omit<ThreadOverwriteContextEvent, 'thread_id'>;
+export type AgentContextProcessorAppendContext = Omit<AgentThreadAppendContext, 'thread_id'>;
+/** Processors omit thread_id — AgentThread stamps it (same as append/overwrite). */
+export type AgentContextProcessorCapabilityState = Omit<InternalCapabilityStateEvent, 'thread_id'>;
+export type AgentContextProcessorOutput = AgentContextProcessorOverwriteContext | AgentContextProcessorAppendContext | InternalPassthroughEvent | AgentContextProcessorCapabilityState;
+export interface PreSendContextProcessor {
+    processPreSend(execution: Readonly<AgentThreadExecutionContext>): AsyncIterable<AgentContextProcessorAppendContext>;
+}
+export interface PreLLMAgentContextProcessor {
+    processPreLLM(execution: Readonly<AgentThreadExecutionContext>): AsyncIterable<AgentContextProcessorOutput>;
+}
+export interface PostToolCallAgentContextProcessor {
+    processPostToolCall(execution: Readonly<AgentThreadExecutionContext>): AsyncIterable<AgentContextProcessorOutput>;
+}
+export interface PreLLMEphemeralAgentContextProcessor {
+    processPreLLMEphemeral(input: ChatCompletionMessageParam[]): ChatCompletionMessageParam[] | undefined;
+}
+//# sourceMappingURL=AgentContextProcessor.d.ts.map

package/dist/core/capabilities/AgentContextProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentContextProcessor.d.ts","sourceRoot":"","sources":["../../../src/core/capabilities/AgentContextProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,KAAK,EACV,wBAAwB,EACxB,cAAc,EACd,4BAA4B,EAC5B,wBAAwB,EACzB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,kFAAkF;AAClF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B;AAED,MAAM,MAAM,qCAAqC,GAAG,IAAI,CAAC,2BAA2B,EAAE,WAAW,CAAC,CAAC;AAEnG,MAAM,MAAM,kCAAkC,GAAG,IAAI,CAAC,wBAAwB,EAAE,WAAW,CAAC,CAAC;AAE7F,oFAAoF;AACpF,MAAM,MAAM,oCAAoC,GAAG,IAAI,CAAC,4BAA4B,EAAE,WAAW,CAAC,CAAC;AAEnG,MAAM,MAAM,2BAA2B,GACnC,qCAAqC,GACrC,kCAAkC,GAClC,wBAAwB,GACxB,oCAAoC,CAAC;AAEzC,MAAM,WAAW,uBAAuB;IACtC,cAAc,CAAC,SAAS,EAAE,QAAQ,CAAC,2BAA2B,CAAC,GAAG,aAAa,CAAC,kCAAkC,CAAC,CAAC;CACrH;AAGD,MAAM,WAAW,2BAA2B;IAC1C,aAAa,CAAC,SAAS,EAAE,QAAQ,CAAC,2BAA2B,CAAC,GAAG,aAAa,CAAC,2BAA2B,CAAC,CAAC;CAC7G;AAED,MAAM,WAAW,iCAAiC;IAChD,mBAAmB,CAAC,SAAS,EAAE,QAAQ,CAAC,2BAA2B,CAAC,GAAG,aAAa,CAAC,2BAA2B,CAAC,CAAC;CACnH;AAGD,MAAM,WAAW,oCAAoC;IACnD,sBAAsB,CAAC,KAAK,EAAE,0BAA0B,EAAE,GAAG,0BAA0B,EAAE,GAAG,SAAS,CAAC;CACvG"}