@dexto/core 1.5.8 → 1.6.0

package/dist/test-utils/in-memory-storage.cjs

@@ -0,0 +1,288 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var in_memory_storage_exports = {};
+__export(in_memory_storage_exports, {
+  createInMemoryBlobStore: () => createInMemoryBlobStore,
+  createInMemoryCache: () => createInMemoryCache,
+  createInMemoryDatabase: () => createInMemoryDatabase,
+  createInMemoryStorageManager: () => createInMemoryStorageManager
+});
+module.exports = __toCommonJS(in_memory_storage_exports);
+var import_storage_manager = require("../storage/storage-manager.js");
+var import_crypto = require("crypto");
+var import_fs = require("fs");
+var import_os = __toESM(require("os"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_stream = require("stream");
+class InMemoryCache {
+  connected = false;
+  entries = /* @__PURE__ */ new Map();
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.entries.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  async get(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return void 0;
+    if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
+      this.entries.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttlSeconds) {
+    const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1e3 : void 0;
+    this.entries.set(key, { value, expiresAt });
+  }
+  async delete(key) {
+    this.entries.delete(key);
+  }
+}
+class InMemoryDatabase {
+  connected = false;
+  data = /* @__PURE__ */ new Map();
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.data.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  async get(key) {
+    return this.data.get(key);
+  }
+  async set(key, value) {
+    this.data.set(key, value);
+  }
+  async delete(key) {
+    this.data.delete(key);
+  }
+  async list(prefix) {
+    return Array.from(this.data.keys()).filter((key) => key.startsWith(prefix));
+  }
+  async append(key, item) {
+    const existing = this.data.get(key);
+    const next = Array.isArray(existing) ? [...existing, item] : [item];
+    this.data.set(key, next);
+  }
+  async getRange(key, start, count) {
+    const existing = this.data.get(key);
+    if (!Array.isArray(existing)) return [];
+    return existing.slice(start, start + count);
+  }
+}
+class InMemoryBlobStore {
+  connected = false;
+  blobs = /* @__PURE__ */ new Map();
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.blobs.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  getStoragePath() {
+    return void 0;
+  }
+  async store(input, metadata) {
+    const { buffer, derivedMimeType } = await coerceBlobInputToBuffer(input);
+    const mimeType = metadata?.mimeType ?? derivedMimeType ?? "application/octet-stream";
+    const createdAt = metadata?.createdAt ?? /* @__PURE__ */ new Date();
+    const hash = (0, import_crypto.createHash)("sha256").update(buffer).digest("hex");
+    const id = (0, import_crypto.randomUUID)();
+    const storedMetadata = {
+      id,
+      mimeType,
+      originalName: metadata?.originalName,
+      createdAt,
+      size: buffer.length,
+      hash,
+      source: metadata?.source
+    };
+    this.blobs.set(id, { data: buffer, metadata: storedMetadata });
+    return {
+      id,
+      uri: `blob:${id}`,
+      metadata: storedMetadata
+    };
+  }
+  async retrieve(reference, format) {
+    const id = normalizeBlobId(reference);
+    const stored = this.blobs.get(id);
+    if (!stored) {
+      throw new Error(`Blob not found: ${reference}`);
+    }
+    const effectiveFormat = format ?? "buffer";
+    switch (effectiveFormat) {
+      case "base64":
+        return {
+          format: "base64",
+          data: stored.data.toString("base64"),
+          metadata: stored.metadata
+        };
+      case "buffer":
+        return { format: "buffer", data: stored.data, metadata: stored.metadata };
+      case "stream":
+        return {
+          format: "stream",
+          data: import_stream.Readable.from(stored.data),
+          metadata: stored.metadata
+        };
+      case "url":
+        return {
+          format: "url",
+          data: `data:${stored.metadata.mimeType};base64,${stored.data.toString("base64")}`,
+          metadata: stored.metadata
+        };
+      case "path": {
+        const outPath = import_path.default.join(import_os.default.tmpdir(), `dexto-blob-${id}`);
+        await import_fs.promises.writeFile(outPath, stored.data);
+        return { format: "path", data: outPath, metadata: stored.metadata };
+      }
+    }
+  }
+  async exists(reference) {
+    const id = normalizeBlobId(reference);
+    return this.blobs.has(id);
+  }
+  async delete(reference) {
+    const id = normalizeBlobId(reference);
+    this.blobs.delete(id);
+  }
+  async cleanup(olderThan) {
+    if (!olderThan) return 0;
+    let deleted = 0;
+    for (const [id, blob] of this.blobs.entries()) {
+      if (blob.metadata.createdAt < olderThan) {
+        this.blobs.delete(id);
+        deleted += 1;
+      }
+    }
+    return deleted;
+  }
+  async getStats() {
+    const sizes = Array.from(this.blobs.values()).map((b) => b.metadata.size);
+    const totalSize = sizes.reduce((sum, size) => sum + size, 0);
+    return {
+      count: this.blobs.size,
+      totalSize,
+      backendType: this.getStoreType(),
+      storePath: "memory"
+    };
+  }
+  async listBlobs() {
+    return Array.from(this.blobs.values()).map((blob) => ({
+      id: blob.metadata.id,
+      uri: `blob:${blob.metadata.id}`,
+      metadata: blob.metadata
+    }));
+  }
+}
+function normalizeBlobId(reference) {
+  return reference.startsWith("blob:") ? reference.slice("blob:".length) : reference;
+}
+async function coerceBlobInputToBuffer(input) {
+  if (Buffer.isBuffer(input)) {
+    return { buffer: input };
+  }
+  if (input instanceof Uint8Array) {
+    return { buffer: Buffer.from(input) };
+  }
+  if (input instanceof ArrayBuffer) {
+    return { buffer: Buffer.from(new Uint8Array(input)) };
+  }
+  if (typeof input !== "string") {
+    return { buffer: Buffer.from(input) };
+  }
+  if (input.startsWith("data:")) {
+    const comma = input.indexOf(",");
+    if (comma === -1) {
+      return { buffer: Buffer.from(input) };
+    }
+    const header = input.slice(0, comma);
+    const data = input.slice(comma + 1);
+    const mimeMatch = header.match(/^data:([^;]+);base64$/);
+    const mimeType = mimeMatch?.[1];
+    return { buffer: Buffer.from(data, "base64"), derivedMimeType: mimeType };
+  }
+  try {
+    return { buffer: await import_fs.promises.readFile(input) };
+  } catch {
+    return { buffer: Buffer.from(input, "base64") };
+  }
+}
+function createInMemoryCache() {
+  return new InMemoryCache();
+}
+function createInMemoryDatabase() {
+  return new InMemoryDatabase();
+}
+function createInMemoryBlobStore() {
+  return new InMemoryBlobStore();
+}
+async function createInMemoryStorageManager(logger) {
+  const manager = new import_storage_manager.StorageManager(
+    {
+      cache: createInMemoryCache(),
+      database: createInMemoryDatabase(),
+      blobStore: createInMemoryBlobStore()
+    },
+    logger
+  );
+  await manager.connect();
+  return manager;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInMemoryBlobStore,
+  createInMemoryCache,
+  createInMemoryDatabase,
+  createInMemoryStorageManager
+});

package/dist/test-utils/in-memory-storage.js

@@ -0,0 +1,252 @@
+import "../chunk-PTJYTZNU.js";
+import { StorageManager } from "../storage/storage-manager.js";
+import { createHash, randomUUID } from "crypto";
+import { promises as fs } from "fs";
+import os from "os";
+import path from "path";
+import { Readable } from "stream";
+class InMemoryCache {
+  connected = false;
+  entries = /* @__PURE__ */ new Map();
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.entries.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  async get(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return void 0;
+    if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
+      this.entries.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttlSeconds) {
+    const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1e3 : void 0;
+    this.entries.set(key, { value, expiresAt });
+  }
+  async delete(key) {
+    this.entries.delete(key);
+  }
+}
+class InMemoryDatabase {
+  connected = false;
+  data = /* @__PURE__ */ new Map();
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.data.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  async get(key) {
+    return this.data.get(key);
+  }
+  async set(key, value) {
+    this.data.set(key, value);
+  }
+  async delete(key) {
+    this.data.delete(key);
+  }
+  async list(prefix) {
+    return Array.from(this.data.keys()).filter((key) => key.startsWith(prefix));
+  }
+  async append(key, item) {
+    const existing = this.data.get(key);
+    const next = Array.isArray(existing) ? [...existing, item] : [item];
+    this.data.set(key, next);
+  }
+  async getRange(key, start, count) {
+    const existing = this.data.get(key);
+    if (!Array.isArray(existing)) return [];
+    return existing.slice(start, start + count);
+  }
+}
+class InMemoryBlobStore {
+  connected = false;
+  blobs = /* @__PURE__ */ new Map();
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.blobs.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  getStoragePath() {
+    return void 0;
+  }
+  async store(input, metadata) {
+    const { buffer, derivedMimeType } = await coerceBlobInputToBuffer(input);
+    const mimeType = metadata?.mimeType ?? derivedMimeType ?? "application/octet-stream";
+    const createdAt = metadata?.createdAt ?? /* @__PURE__ */ new Date();
+    const hash = createHash("sha256").update(buffer).digest("hex");
+    const id = randomUUID();
+    const storedMetadata = {
+      id,
+      mimeType,
+      originalName: metadata?.originalName,
+      createdAt,
+      size: buffer.length,
+      hash,
+      source: metadata?.source
+    };
+    this.blobs.set(id, { data: buffer, metadata: storedMetadata });
+    return {
+      id,
+      uri: `blob:${id}`,
+      metadata: storedMetadata
+    };
+  }
+  async retrieve(reference, format) {
+    const id = normalizeBlobId(reference);
+    const stored = this.blobs.get(id);
+    if (!stored) {
+      throw new Error(`Blob not found: ${reference}`);
+    }
+    const effectiveFormat = format ?? "buffer";
+    switch (effectiveFormat) {
+      case "base64":
+        return {
+          format: "base64",
+          data: stored.data.toString("base64"),
+          metadata: stored.metadata
+        };
+      case "buffer":
+        return { format: "buffer", data: stored.data, metadata: stored.metadata };
+      case "stream":
+        return {
+          format: "stream",
+          data: Readable.from(stored.data),
+          metadata: stored.metadata
+        };
+      case "url":
+        return {
+          format: "url",
+          data: `data:${stored.metadata.mimeType};base64,${stored.data.toString("base64")}`,
+          metadata: stored.metadata
+        };
+      case "path": {
+        const outPath = path.join(os.tmpdir(), `dexto-blob-${id}`);
+        await fs.writeFile(outPath, stored.data);
+        return { format: "path", data: outPath, metadata: stored.metadata };
+      }
+    }
+  }
+  async exists(reference) {
+    const id = normalizeBlobId(reference);
+    return this.blobs.has(id);
+  }
+  async delete(reference) {
+    const id = normalizeBlobId(reference);
+    this.blobs.delete(id);
+  }
+  async cleanup(olderThan) {
+    if (!olderThan) return 0;
+    let deleted = 0;
+    for (const [id, blob] of this.blobs.entries()) {
+      if (blob.metadata.createdAt < olderThan) {
+        this.blobs.delete(id);
+        deleted += 1;
+      }
+    }
+    return deleted;
+  }
+  async getStats() {
+    const sizes = Array.from(this.blobs.values()).map((b) => b.metadata.size);
+    const totalSize = sizes.reduce((sum, size) => sum + size, 0);
+    return {
+      count: this.blobs.size,
+      totalSize,
+      backendType: this.getStoreType(),
+      storePath: "memory"
+    };
+  }
+  async listBlobs() {
+    return Array.from(this.blobs.values()).map((blob) => ({
+      id: blob.metadata.id,
+      uri: `blob:${blob.metadata.id}`,
+      metadata: blob.metadata
+    }));
+  }
+}
+function normalizeBlobId(reference) {
+  return reference.startsWith("blob:") ? reference.slice("blob:".length) : reference;
+}
+async function coerceBlobInputToBuffer(input) {
+  if (Buffer.isBuffer(input)) {
+    return { buffer: input };
+  }
+  if (input instanceof Uint8Array) {
+    return { buffer: Buffer.from(input) };
+  }
+  if (input instanceof ArrayBuffer) {
+    return { buffer: Buffer.from(new Uint8Array(input)) };
+  }
+  if (typeof input !== "string") {
+    return { buffer: Buffer.from(input) };
+  }
+  if (input.startsWith("data:")) {
+    const comma = input.indexOf(",");
+    if (comma === -1) {
+      return { buffer: Buffer.from(input) };
+    }
+    const header = input.slice(0, comma);
+    const data = input.slice(comma + 1);
+    const mimeMatch = header.match(/^data:([^;]+);base64$/);
+    const mimeType = mimeMatch?.[1];
+    return { buffer: Buffer.from(data, "base64"), derivedMimeType: mimeType };
+  }
+  try {
+    return { buffer: await fs.readFile(input) };
+  } catch {
+    return { buffer: Buffer.from(input, "base64") };
+  }
+}
+function createInMemoryCache() {
+  return new InMemoryCache();
+}
+function createInMemoryDatabase() {
+  return new InMemoryDatabase();
+}
+function createInMemoryBlobStore() {
+  return new InMemoryBlobStore();
+}
+async function createInMemoryStorageManager(logger) {
+  const manager = new StorageManager(
+    {
+      cache: createInMemoryCache(),
+      database: createInMemoryDatabase(),
+      blobStore: createInMemoryBlobStore()
+    },
+    logger
+  );
+  await manager.connect();
+  return manager;
+}
+export {
+  createInMemoryBlobStore,
+  createInMemoryCache,
+  createInMemoryDatabase,
+  createInMemoryStorageManager
+};

package/dist/tools/confirmation/allowed-tools-provider/factory.d.ts

@@ -1,6 +1,6 @@
-import type { IAllowedToolsProvider } from './types.js';
+import type { AllowedToolsProvider } from './types.js';
 import type { StorageManager } from '../../../storage/index.js';
-import type { IDextoLogger } from '../../../logger/v2/types.js';
+import type { Logger } from '../../../logger/v2/types.js';
 export type AllowedToolsConfig = {
     type: 'memory';
 } | {
@@ -10,5 +10,5 @@ export type AllowedToolsConfig = {
 /**
  * Create an AllowedToolsProvider based on configuration.
  */
-export declare function createAllowedToolsProvider(config: AllowedToolsConfig, logger: IDextoLogger): IAllowedToolsProvider;
+export declare function createAllowedToolsProvider(config: AllowedToolsConfig, logger: Logger): AllowedToolsProvider;
 //# sourceMappingURL=factory.d.ts.map

package/dist/tools/confirmation/allowed-tools-provider/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/factory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAU7D,MAAM,MAAM,kBAAkB,GACxB;IACI,IAAI,EAAE,QAAQ,CAAC;CAClB,GACD;IACI,IAAI,EAAE,SAAS,CAAC;IAChB,cAAc,EAAE,cAAc,CAAC;CAClC,CAAC;AAER;;GAEG;AACH,wBAAgB,0BAA0B,CACtC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,YAAY,GACrB,qBAAqB,CAcvB"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/factory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAU1D,MAAM,MAAM,kBAAkB,GACxB;IACI,IAAI,EAAE,QAAQ,CAAC;CAClB,GACD;IACI,IAAI,EAAE,SAAS,CAAC;IAChB,cAAc,EAAE,cAAc,CAAC;CAClC,CAAC;AAER;;GAEG;AACH,wBAAgB,0BAA0B,CACtC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,MAAM,GACf,oBAAoB,CActB"}

package/dist/tools/confirmation/allowed-tools-provider/in-memory.d.ts

@@ -1,5 +1,5 @@
-import type { IAllowedToolsProvider } from './types.js';
-export declare class InMemoryAllowedToolsProvider implements IAllowedToolsProvider {
+import type { AllowedToolsProvider } from './types.js';
+export declare class InMemoryAllowedToolsProvider implements AllowedToolsProvider {
     /**
      * Map key is sessionId (undefined => global approvals). Value is a set of
      * approved tool names.

package/dist/tools/confirmation/allowed-tools-provider/in-memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/in-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,qBAAa,4BAA6B,YAAW,qBAAqB;IACtE;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAmD;gBAEpD,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;IAMvC,OAAO,CAAC,MAAM;IAUR,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9D,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrE,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;CAGlE"}
+{"version":3,"file":"in-memory.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/in-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,qBAAa,4BAA6B,YAAW,oBAAoB;IACrE;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAmD;gBAEpD,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;IAMvC,OAAO,CAAC,MAAM;IAUR,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9D,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrE,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;CAGlE"}

package/dist/tools/confirmation/allowed-tools-provider/storage.d.ts

@@ -1,6 +1,6 @@
 import type { StorageManager } from '../../../storage/index.js';
-import type { IAllowedToolsProvider } from './types.js';
-import type { IDextoLogger } from '../../../logger/v2/types.js';
+import type { AllowedToolsProvider } from './types.js';
+import type { Logger } from '../../../logger/v2/types.js';
 /**
  * Storage-backed implementation that persists allowed tools in the Dexto
  * storage manager. The key scheme is:
@@ -9,10 +9,10 @@ import type { IDextoLogger } from '../../../logger/v2/types.js';
  *
  * Using the database backend for persistence.
  */
-export declare class StorageAllowedToolsProvider implements IAllowedToolsProvider {
+export declare class StorageAllowedToolsProvider implements AllowedToolsProvider {
     private storageManager;
     private logger;
-    constructor(storageManager: StorageManager, logger: IDextoLogger);
+    constructor(storageManager: StorageManager, logger: Logger);
     private buildKey;
     allowTool(toolName: string, sessionId?: string): Promise<void>;
     disallowTool(toolName: string, sessionId?: string): Promise<void>;

package/dist/tools/confirmation/allowed-tools-provider/storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;GAOG;AACH,qBAAa,2BAA4B,YAAW,qBAAqB;IAIjE,OAAO,CAAC,cAAc;IAH1B,OAAO,CAAC,MAAM,CAAe;gBAGjB,cAAc,EAAE,cAAc,EACtC,MAAM,EAAE,YAAY;IAKxB,OAAO,CAAC,QAAQ;IAIV,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9D,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBrE,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;CAIlE"}
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D;;;;;;;GAOG;AACH,qBAAa,2BAA4B,YAAW,oBAAoB;IAIhE,OAAO,CAAC,cAAc;IAH1B,OAAO,CAAC,MAAM,CAAS;gBAGX,cAAc,EAAE,cAAc,EACtC,MAAM,EAAE,MAAM;IAKlB,OAAO,CAAC,QAAQ;IAIV,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9D,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBrE,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;CAIlE"}

package/dist/tools/confirmation/allowed-tools-provider/types.d.ts

@@ -15,7 +15,7 @@
  * - We can enforce this by having a separate env variable/feature-flag for multi-user and having
  *   strict check for the user id if the feature flag is set.
  */
-export interface IAllowedToolsProvider {
+export type AllowedToolsProvider = {
     /**
      * Persist an approval for a tool. If `sessionId` is provided the approval is
      * scoped to that session. When omitted the approval is treated as global.
@@ -30,5 +30,5 @@ export interface IAllowedToolsProvider {
     isToolAllowed(toolName: string, sessionId?: string): Promise<boolean>;
     /** Optional helper to introspect all approvals for debugging. */
     getAllowedTools?(sessionId?: string): Promise<Set<string>>;
-}
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/tools/confirmation/allowed-tools-provider/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,qBAAqB;IAClC;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/D,0BAA0B;IAC1B,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElE;;;OAGG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtE,iEAAiE;IACjE,eAAe,CAAC,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CAC9D"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tools/confirmation/allowed-tools-provider/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAC/B;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/D,0BAA0B;IAC1B,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElE;;;OAGG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtE,iEAAiE;IACjE,eAAe,CAAC,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CAC9D,CAAC"}

package/dist/tools/{internal-tools/constants.cjs → define-tool.cjs}

@@ -16,20 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var constants_exports = {};
-__export(constants_exports, {
-  INTERNAL_TOOL_NAMES: () => INTERNAL_TOOL_NAMES
+var define_tool_exports = {};
+__export(define_tool_exports, {
+  defineTool: () => defineTool
 });
-module.exports = __toCommonJS(constants_exports);
-const INTERNAL_TOOL_NAMES = [
-  "search_history",
-  "ask_user",
-  "delegate_to_url",
-  "list_resources",
-  "get_resource",
-  "invoke_skill"
-];
+module.exports = __toCommonJS(define_tool_exports);
+function defineTool(tool) {
+  return tool;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  INTERNAL_TOOL_NAMES
+  defineTool
 });

package/dist/tools/define-tool.d.ts

@@ -0,0 +1,11 @@
+import type { ZodTypeAny } from 'zod';
+import type { Tool } from './types.js';
+/**
+ * Typed identity helper for defining tools.
+ *
+ * Why: TypeScript only infers `execute(...)` argument types from `inputSchema` reliably
+ * when the object literal is contextually typed. `defineTool(...)` provides that
+ * context and keeps tool definitions consistent across packages.
+ */
+export declare function defineTool<const TSchema extends ZodTypeAny>(tool: Tool<TSchema>): Tool<TSchema>;
+//# sourceMappingURL=define-tool.d.ts.map

package/dist/tools/define-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-tool.d.ts","sourceRoot":"","sources":["../../src/tools/define-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,CAAC,OAAO,SAAS,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAE/F"}

package/dist/tools/define-tool.js

@@ -0,0 +1,7 @@
+import "../chunk-PTJYTZNU.js";
+function defineTool(tool) {
+  return tool;
+}
+export {
+  defineTool
+};