@5ss/ai-tools 2.11.1

package/dist/index-CCivzmxO.d.ts

@@ -0,0 +1,188 @@
+import { a as ModuleDefinition, o as ToolContext, s as ToolDefinition } from "./types-Ccb0DXY9.js";
+import "./index-CZX5OeOF.js";
+import { c as UpsertVectorsInput, l as UpsertVectorsOutput, n as DeleteVectorsOutput, o as QueryVectorsInput, s as QueryVectorsOutput, t as DeleteVectorsInput } from "./index-ccZ1XOHw.js";
+import { z } from "zod";
+//#region src/modules/vector-store/contracts.d.ts
+declare const qdrantVectorAuthSchema: z.ZodObject<{
+  base_url: z.ZodString;
+  api_key: z.ZodOptional<z.ZodString>;
+  default_collection: z.ZodOptional<z.ZodString>;
+  default_filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  provider: z.ZodLiteral<"qdrant">;
+}, z.core.$strip>;
+declare const pineconeVectorAuthSchema: z.ZodObject<{
+  api_key: z.ZodString;
+  base_url: z.ZodString;
+  default_namespace: z.ZodOptional<z.ZodString>;
+  default_filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  provider: z.ZodLiteral<"pinecone">;
+}, z.core.$strip>;
+declare const supabaseVectorSeamAuthSchema: z.ZodObject<{
+  url: z.ZodString;
+  api_key: z.ZodString;
+  default_collection: z.ZodOptional<z.ZodString>;
+  schema: z.ZodOptional<z.ZodString>;
+  id_column: z.ZodOptional<z.ZodString>;
+  embedding_column: z.ZodOptional<z.ZodString>;
+  metadata_column: z.ZodOptional<z.ZodString>;
+  match_rpc: z.ZodOptional<z.ZodString>;
+  default_filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  provider: z.ZodLiteral<"supabase">;
+}, z.core.$strip>;
+declare const mastraVectorSeamAuthSchema: z.ZodObject<{
+  connection_string: z.ZodString;
+  id: z.ZodString;
+  schema_name: z.ZodOptional<z.ZodString>;
+  default_index: z.ZodOptional<z.ZodString>;
+  dimension: z.ZodOptional<z.ZodNumber>;
+  auto_create_index: z.ZodOptional<z.ZodBoolean>;
+  disable_init: z.ZodOptional<z.ZodBoolean>;
+  default_filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  provider: z.ZodLiteral<"mastra">;
+}, z.core.$strip>;
+declare const vectorStoreAuthSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  base_url: z.ZodString;
+  api_key: z.ZodOptional<z.ZodString>;
+  default_collection: z.ZodOptional<z.ZodString>;
+  default_filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  provider: z.ZodLiteral<"qdrant">;
+}, z.core.$strip>, z.ZodObject<{
+  api_key: z.ZodString;
+  base_url: z.ZodString;
+  default_namespace: z.ZodOptional<z.ZodString>;
+  default_filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  provider: z.ZodLiteral<"pinecone">;
+}, z.core.$strip>, z.ZodObject<{
+  url: z.ZodString;
+  api_key: z.ZodString;
+  default_collection: z.ZodOptional<z.ZodString>;
+  schema: z.ZodOptional<z.ZodString>;
+  id_column: z.ZodOptional<z.ZodString>;
+  embedding_column: z.ZodOptional<z.ZodString>;
+  metadata_column: z.ZodOptional<z.ZodString>;
+  match_rpc: z.ZodOptional<z.ZodString>;
+  default_filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  provider: z.ZodLiteral<"supabase">;
+}, z.core.$strip>, z.ZodObject<{
+  connection_string: z.ZodString;
+  id: z.ZodString;
+  schema_name: z.ZodOptional<z.ZodString>;
+  default_index: z.ZodOptional<z.ZodString>;
+  dimension: z.ZodOptional<z.ZodNumber>;
+  auto_create_index: z.ZodOptional<z.ZodBoolean>;
+  disable_init: z.ZodOptional<z.ZodBoolean>;
+  default_filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  provider: z.ZodLiteral<"mastra">;
+}, z.core.$strip>], "provider">;
+type QdrantVectorAuth = z.infer<typeof qdrantVectorAuthSchema>;
+type PineconeVectorAuth = z.infer<typeof pineconeVectorAuthSchema>;
+type SupabaseVectorSeamAuth = z.infer<typeof supabaseVectorSeamAuthSchema>;
+type MastraVectorSeamAuth = z.infer<typeof mastraVectorSeamAuthSchema>;
+type VectorStoreAuth = z.infer<typeof vectorStoreAuthSchema>;
+/** Shared seam surface — provider classes implement this. */
+type VectorStoreOps = {
+  upsert: (input: UpsertVectorsInput) => Promise<UpsertVectorsOutput>;
+  query: (input: QueryVectorsInput) => Promise<QueryVectorsOutput>;
+  delete: (input: DeleteVectorsInput) => Promise<DeleteVectorsOutput>;
+};
+//#endregion
+//#region src/modules/vector-store/client.d.ts
+declare class VectorStoreClient implements VectorStoreOps {
+  #private;
+  constructor(ops: VectorStoreOps);
+  static fromContext(ctx: ToolContext): VectorStoreClient;
+  static fromAuth(auth: VectorStoreAuth, ctx?: ToolContext): VectorStoreClient;
+  upsert(input: UpsertVectorsInput): Promise<{
+    upserted: number;
+    collection?: string | undefined;
+  }>;
+  query(input: QueryVectorsInput): Promise<{
+    matches: {
+      id: string;
+      score: number;
+      values?: number[] | undefined;
+      metadata?: Record<string, string | number | boolean | null> | undefined;
+    }[];
+    collection?: string | undefined;
+  }>;
+  delete(input: DeleteVectorsInput): Promise<{
+    deleted: number;
+    collection?: string | undefined;
+  }>;
+}
+//#endregion
+//#region src/modules/vector-store/module.d.ts
+declare const vectorStoreUpsertTool: ToolDefinition<{
+  collection?: string | undefined;
+  namespace?: string | undefined;
+  vectors: {
+    id: string;
+    values: number[];
+    metadata?: Record<string, string | number | boolean | null> | undefined;
+  }[];
+}, {
+  upserted: number;
+  collection?: string | undefined;
+}>;
+declare const vectorStoreQueryTool: ToolDefinition<{
+  collection?: string | undefined;
+  namespace?: string | undefined;
+  vector: number[];
+  top_k?: number | undefined;
+  include_values?: boolean | undefined;
+  include_metadata?: boolean | undefined;
+  filter?: Record<string, unknown> | undefined;
+}, {
+  matches: {
+    id: string;
+    score: number;
+    values?: number[] | undefined;
+    metadata?: Record<string, string | number | boolean | null> | undefined;
+  }[];
+  collection?: string | undefined;
+}>;
+declare const vectorStoreDeleteTool: ToolDefinition<{
+  collection?: string | undefined;
+  namespace?: string | undefined;
+  ids: string[];
+}, {
+  deleted: number;
+  collection?: string | undefined;
+}>;
+declare const vectorStoreModule: ModuleDefinition<{
+  base_url: string;
+  api_key?: string | undefined;
+  default_collection?: string | undefined;
+  default_filter?: Record<string, unknown> | undefined;
+  provider: "qdrant";
+} | {
+  api_key: string;
+  base_url: string;
+  default_namespace?: string | undefined;
+  default_filter?: Record<string, unknown> | undefined;
+  provider: "pinecone";
+} | {
+  url: string;
+  api_key: string;
+  default_collection?: string | undefined;
+  schema?: string | undefined;
+  id_column?: string | undefined;
+  embedding_column?: string | undefined;
+  metadata_column?: string | undefined;
+  match_rpc?: string | undefined;
+  default_filter?: Record<string, unknown> | undefined;
+  provider: "supabase";
+} | {
+  connection_string: string;
+  id: string;
+  schema_name?: string | undefined;
+  default_index?: string | undefined;
+  dimension?: number | undefined;
+  auto_create_index?: boolean | undefined;
+  disable_init?: boolean | undefined;
+  default_filter?: Record<string, unknown> | undefined;
+  provider: "mastra";
+}>;
+//#endregion
+export { VectorStoreClient as a, QdrantVectorAuth as c, VectorStoreOps as d, mastraVectorSeamAuthSchema as f, vectorStoreAuthSchema as g, supabaseVectorSeamAuthSchema as h, vectorStoreUpsertTool as i, SupabaseVectorSeamAuth as l, qdrantVectorAuthSchema as m, vectorStoreModule as n, MastraVectorSeamAuth as o, pineconeVectorAuthSchema as p, vectorStoreQueryTool as r, PineconeVectorAuth as s, vectorStoreDeleteTool as t, VectorStoreAuth as u };
+//# sourceMappingURL=index-CCivzmxO.d.ts.map

package/dist/index-CCivzmxO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CCivzmxO.d.ts","names":[],"sources":["../src/modules/vector-store/contracts.ts","../src/modules/vector-store/client.ts","../src/modules/vector-store/module.ts"],"mappings":";;;;;cAuDa,wBAAsB,EAAA;;;;;;GAEjC,EAAA,KAAA;cAEW,0BAAwB,EAAA;;;;;;GAEnC,EAAA,KAAA;cAEW,8BAA4B,EAAA;;;;;;;;;;;GAEvC,EAAA,KAAA;cAEW,4BAA0B,EAAA;;;;;;;;;;GAErC,EAAA,KAAA;cAEW,uBAAqB,EAAA,uBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKhC,EAAA,KAAA;KAEU,mBAAmB,EAAE,aAAa;KAClC,qBAAqB,EAAE,aAAa;KACpC,yBAAyB,EAAE,aAAa;KACxC,uBAAuB,EAAE,aAAa;KACtC,kBAAkB,EAAE,aAAa;;KAGjC;EACX,SAAS,OAAO,uBAAuB,QAAQ;EAC/C,QAAQ,OAAO,sBAAsB,QAAQ;EAC7C,SAAS,OAAO,uBAAuB,QAAQ;;;;cChDnC,6BAA6B;;EAGzC,YAAY,KAAK;SAIV,YAAY,KAAK,cAAc;SAK/B,SAAS,MAAM,iBAAiB,MAAK,cAAmB;EAI/D,OAAO,OAAO,qBAAkB;;;;EAIhC,MAAM,OAAO,oBAAiB;;;;;;;;;EAI9B,OAAO,OAAO,qBAAkB;;;;;;;cCjDpB,uBAAA;;;;;;eAAA;;;;;;cAYA;;;;;;;;;;;;;;;;;cAYA,uBAAA;;;;;;;;cAWA"}

package/dist/index-CLmTrcu5.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+//#region src/vendors/_email/schemas.d.ts
+declare const MAX_EMAIL_BYTES: number;
+declare const MAX_BATCH_EMAILS = 20;
+declare const namedAddressSchema: z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+  email: z.ZodEmail;
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+type NamedAddress = z.infer<typeof namedAddressSchema>;
+declare const attachmentSchema: z.ZodObject<{
+  content: z.ZodString;
+  filename: z.ZodString;
+  type: z.ZodString;
+  disposition: z.ZodOptional<z.ZodEnum<{
+    attachment: "attachment";
+    inline: "inline";
+  }>>;
+  content_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//#endregion
+export { namedAddressSchema as a, attachmentSchema as i, MAX_EMAIL_BYTES as n, NamedAddress as r, MAX_BATCH_EMAILS as t };
+//# sourceMappingURL=index-CLmTrcu5.d.ts.map

package/dist/index-CLmTrcu5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CLmTrcu5.d.ts","names":[],"sources":["../src/vendors/_email/schemas.ts"],"mappings":";;cAOa;cACA;cAIA,oBAAkB,EAAA,mBAAA,EAAA,UAAA,EAAA;;;GAM7B,EAAA,KAAA;KAEU,eAAe,EAAE,aAAa;cAE7B,kBAAgB,EAAA;;;;;;;;;GAW3B,EAAA,KAAA"}

package/dist/index-CZX5OeOF.d.ts

@@ -0,0 +1,235 @@
+import { a as ModuleDefinition, d as ToolHookToolRef, f as ToolHooks, g as ToolSource, h as ToolSideEffect, i as ModuleClassification, l as ToolExecution, m as ToolRuntime, n as AuthDefinition, o as ToolContext, p as ToolMeta, s as ToolDefinition } from "./types-Ccb0DXY9.js";
+import { z } from "zod";
+//#region src/core/filter-tools.d.ts
+/**
+ * Exactly one of `only` or `except`.
+ * Host wrappers can accept this same contract without redefining it.
+ */
+type ToolSelection = {
+  only: readonly string[];
+  except?: never;
+} | {
+  except: readonly string[];
+  only?: never;
+};
+/** @deprecated Use {@link ToolSelection}. */
+type ToolIdFilter = ToolSelection;
+/** @deprecated Use {@link ToolSelection} with `{ only }`. */
+type OnlyToolsFilter = Extract<ToolSelection, {
+  only: readonly string[];
+}>;
+/** @deprecated Use {@link ToolSelection} with `{ except }`. */
+type ExceptToolsFilter = Extract<ToolSelection, {
+  except: readonly string[];
+}>;
+/** Tool ids present on a module (string union when tool `id` is a string literal). */
+type ModuleToolId<M extends ModuleDefinition> = M['tools'][number]['id'];
+/**
+ * Keep only the listed tool ids. Unknown ids throw. Empty `ids` throws.
+ * Order follows the original module tool list (not the `ids` array order).
+ */
+declare function onlyTools<TAuth, const TId extends string = string>(module: ModuleDefinition<TAuth>, ids: readonly TId[]): ModuleDefinition<TAuth>;
+/**
+ * Drop the listed tool ids. Unknown ids throw. Empty `ids` returns the module unchanged.
+ * Order follows the original module tool list.
+ */
+declare function exceptTools<TAuth, const TId extends string = string>(module: ModuleDefinition<TAuth>, ids: readonly TId[]): ModuleDefinition<TAuth>;
+/** Apply an `only` or `except` selection. */
+declare function filterModuleTools<TAuth>(module: ModuleDefinition<TAuth>, selection: ToolSelection): ModuleDefinition<TAuth>;
+//#endregion
+//#region src/core/hooks.d.ts
+declare function withHooksTool<TInput, TOutput>(tool: ToolDefinition<TInput, TOutput>, hooks: ToolHooks): ToolDefinition<TInput, TOutput>;
+declare function withHooks<TAuth>(module: ModuleDefinition<TAuth>, hooks: ToolHooks): ModuleDefinition<TAuth>;
+declare function toolRef(tool: ToolHookToolRef): ToolHookToolRef;
+//#endregion
+//#region src/core/bind.d.ts
+type BindModuleOptions<TAuth = unknown> = {
+  resolveAuth?: (ctx: ToolContext) => TAuth | Promise<TAuth>;
+  resolveContext?: (ctx: ToolContext) => ToolContext | Promise<ToolContext>;
+  hooks?: ToolHooks;
+  /**
+   * Restrict the tool surface after bind.
+   * Prefer composable `onlyTools` / `exceptTools` when filtering outside bind.
+   */
+  tools?: ToolSelection;
+};
+declare function bindTool<TInput, TOutput, TAuth = unknown>(tool: ToolDefinition<TInput, TOutput>, moduleAuth: AuthDefinition<TAuth>, options: BindModuleOptions<TAuth>): ToolDefinition<TInput, TOutput>;
+declare function bindModule<TAuth>(module: ModuleDefinition<TAuth>, options: BindModuleOptions<TAuth>): ModuleDefinition<TAuth>;
+//#endregion
+//#region src/core/context.d.ts
+/**
+ * Overlay wins for fields that are **present and defined**.
+ * `{ signal: undefined }` does not clear base.signal.
+ * `extras` are shallow-merged when overlay sets them.
+ */
+declare function mergeToolContext(base: ToolContext, overlay?: ToolContext): ToolContext;
+//#endregion
+//#region src/core/contracts.d.ts
+type ContractIssue = {
+  code: 'duplicate_tool_id' | 'empty_description' | 'empty_field_description' | 'forbidden_model_copy' | 'invalid_tool_id' | 'missing_name';
+  message: string;
+  path: string;
+};
+type ContractResult = {
+  ok: boolean;
+  issues: ContractIssue[];
+};
+type CheckModelCopyOptions = {
+  /** When true, also ban vendor brand names (capability seams). */
+  seam?: boolean;
+};
+declare function validateTool(tool: ToolDefinition, pathPrefix?: string, options?: CheckModelCopyOptions): ContractResult;
+declare function validateModule(module: ModuleDefinition): ContractResult;
+declare function assertContracts(result: ContractResult, label?: string): void;
+//#endregion
+//#region src/core/catalog.d.ts
+type ToolCatalogEntry = {
+  description: string;
+  id: string;
+  inputJsonSchema: Record<string, unknown>;
+  name: string;
+  outputJsonSchema: Record<string, unknown>;
+  runtime: ToolDefinition['meta']['runtime'];
+  sideEffect: ToolDefinition['meta']['sideEffect'];
+  tags: readonly string[];
+  idempotent?: boolean | undefined;
+  longRunning?: boolean | undefined;
+  requiresConfirmation?: boolean | undefined;
+  supportsCancel?: boolean | undefined;
+  supportsProgress?: boolean | undefined;
+  network?: boolean | undefined;
+  artifacts?: boolean | undefined;
+};
+type ModuleCatalogEntry = {
+  authType: AuthDefinition<unknown>['type'];
+  description: string;
+  id: string;
+  runtime: ModuleDefinition['runtime'];
+  title: string;
+  tools: ToolCatalogEntry[];
+  /** Inline SVG when the pack has a logo. */
+  logo?: string | undefined;
+  categories: readonly string[];
+  classification?: ModuleDefinition['classification'];
+  tags: readonly string[];
+};
+declare function toToolCatalogEntry(tool: ToolDefinition): ToolCatalogEntry;
+declare function toModuleCatalogEntry(module: ModuleDefinition): ModuleCatalogEntry;
+//#endregion
+//#region src/core/define.d.ts
+type DefineToolOptions<TInput, TOutput> = {
+  description: string;
+  id: string;
+  inputSchema: ToolDefinition<TInput, TOutput>['inputSchema'];
+  name: string;
+  outputSchema: ToolDefinition<TInput, TOutput>['outputSchema'];
+  runtime?: ToolRuntime;
+  sideEffect?: ToolSideEffect;
+  tags?: readonly string[];
+  /** Host-facing hints (not enforced by the kernel). */
+  idempotent?: boolean;
+  longRunning?: boolean;
+  requiresConfirmation?: boolean;
+  supportsCancel?: boolean;
+  supportsProgress?: boolean;
+  network?: boolean;
+  artifacts?: boolean;
+  execute: (input: TInput, ctx: ToolContext) => Promise<TOutput>;
+};
+declare function defineTool<TInput, TOutput>(options: DefineToolOptions<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
+/** @deprecated Prefer defineTool return value directly; kept for call-site clarity in modules. */
+declare function asAnyTool<TInput, TOutput>(tool: ToolDefinition<TInput, TOutput>): ToolDefinition;
+type DefineModuleOptions<TAuth = unknown> = {
+  auth?: AuthDefinition<TAuth>;
+  description: string;
+  id: string;
+  runtime?: ToolRuntime;
+  title: string;
+  tools: readonly ToolDefinition[];
+  /** Optional override; default comes from the pack logo map by module id. */
+  logo?: string | undefined;
+  /**
+   * Catalog categories for UI filters / MCP / skill grouping.
+   * Declared on the pack (`module.ts`) — not a central registry in core.
+   */
+  categories?: readonly string[];
+  /** Host sensitivity hint (`standard` | `pii` | `phi`). Pack declares; host enforces. */
+  classification?: ModuleClassification;
+  /** Module-level search / badge labels. */
+  tags?: readonly string[];
+};
+declare function defineModule<TAuth = unknown>(options: DefineModuleOptions<TAuth>): ModuleDefinition<TAuth>;
+//#endregion
+//#region src/generated/pack-logos.d.ts
+/** Inline SVG by module / pack id (shared files referenced many times). */
+declare const packLogosByModuleId: Readonly<Record<string, string>>;
+declare function logoForModuleId(id: string): string | undefined;
+//#endregion
+//#region src/core/provider.d.ts
+/**
+ * Provider type-class entry for a capability module.
+ * Auth schemas always include a `provider` literal discriminator.
+ * Ops receive auth only via `ctx.auth` (never tool inputs).
+ */
+type ProviderDefinition<TId extends string = string, TAuth = unknown, TOps = unknown> = {
+  id: TId;
+  title: string;
+  authSchema: z.ZodType<TAuth>;
+  ops: TOps;
+};
+type ProviderAuthBase = {
+  provider: string;
+};
+declare function defineProvider<const TId extends string, TAuth extends {
+  provider: TId;
+}, TOps>(options: {
+  id: TId;
+  title: string;
+  authSchema: z.ZodType<TAuth>;
+  ops: TOps;
+}): ProviderDefinition<TId, TAuth, TOps>;
+/** Resolve a registered provider by `auth.provider`. */
+declare function resolveProvider<T extends ProviderDefinition>(providers: readonly T[], auth: ProviderAuthBase): T;
+/** Parse host-bound credentials for a module auth schema. */
+declare function requireAuth<TAuth>(ctx: ToolContext, schema: z.ZodType<TAuth>): TAuth;
+//#endregion
+//#region src/core/resolve-tools.d.ts
+declare function isToolArray(source: ToolSource): source is readonly ToolDefinition[];
+/** Normalize a module or tool list into a flat tool list. */
+declare function resolveTools(source: ToolSource): readonly ToolDefinition[];
+declare function filterToolsByRuntime(tools: readonly ToolDefinition[], runtime: 'edge' | 'node'): ToolDefinition[];
+//#endregion
+//#region src/core/unique.d.ts
+/** Keys that appear more than once (via `by`). */
+declare function duplicatesBy<T>(items: readonly T[], by: (item: T) => string): string[];
+/** First duplicate key, if any. */
+declare function firstDuplicateBy<T>(items: readonly T[], by: (item: T) => string): string | undefined;
+/** Throw if any key from `by` is duplicated. */
+declare function assertUniqueBy<T>(items: readonly T[], by: (item: T) => string, message: (duplicate: string) => string): void;
+//#endregion
+//#region src/core/with-auth.d.ts
+declare function withAuthTool<TInput, TOutput>(tool: ToolDefinition<TInput, TOutput>, auth: unknown): ToolDefinition<TInput, TOutput>;
+type WithAuthOptions = {
+  /**
+   * Restrict the tool surface after bind.
+   * Prefer composable `onlyTools` / `exceptTools` when filtering outside withAuth.
+   */
+  tools?: ToolSelection;
+};
+declare function withAuth<TAuth>(module: ModuleDefinition<TAuth>, auth?: TAuth, options?: WithAuthOptions): ModuleDefinition<TAuth>;
+type RunnableTool<TInput, TOutput> = {
+  id?: string;
+  name?: string;
+  description?: string;
+  meta?: ToolMeta;
+  execution?: ToolExecution | undefined;
+  inputSchema: ToolDefinition<TInput, TOutput>['inputSchema'];
+  outputSchema: ToolDefinition<TInput, TOutput>['outputSchema'];
+  execute: (input: unknown, ctx: ToolContext) => Promise<unknown>;
+};
+/** Validate in → execute → validate out once → artifact callbacks → afterExecute. */
+declare function runTool<TInput, TOutput>(tool: RunnableTool<TInput, TOutput>, input: TInput, ctx?: ToolContext): Promise<TOutput>;
+declare function listTools(module: ModuleDefinition): readonly ToolDefinition[];
+//#endregion
+export { assertContracts as A, ExceptToolsFilter as B, defineTool as C, toToolCatalogEntry as D, toModuleCatalogEntry as E, bindModule as F, exceptTools as G, OnlyToolsFilter as H, bindTool as I, filterModuleTools as K, toolRef as L, validateTool as M, mergeToolContext as N, ContractIssue as O, BindModuleOptions as P, withHooks as R, defineModule as S, ToolCatalogEntry as T, ToolIdFilter as U, ModuleToolId as V, ToolSelection as W, logoForModuleId as _, withAuthTool as a, DefineToolOptions as b, firstDuplicateBy as c, resolveTools as d, ProviderAuthBase as f, resolveProvider as g, requireAuth as h, withAuth as i, validateModule as j, ContractResult as k, filterToolsByRuntime as l, defineProvider as m, listTools as n, assertUniqueBy as o, ProviderDefinition as p, onlyTools as q, runTool as r, duplicatesBy as s, WithAuthOptions as t, isToolArray as u, packLogosByModuleId as v, ModuleCatalogEntry as w, asAnyTool as x, DefineModuleOptions as y, withHooksTool as z };
+//# sourceMappingURL=index-CZX5OeOF.d.ts.map

package/dist/index-CZX5OeOF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CZX5OeOF.d.ts","names":[],"sources":["../src/core/filter-tools.ts","../src/core/hooks.ts","../src/core/bind.ts","../src/core/context.ts","../src/core/contracts.ts","../src/core/catalog.ts","../src/core/define.ts","../src/generated/pack-logos.ts","../src/core/provider.ts","../src/core/resolve-tools.ts","../src/core/unique.ts","../src/core/with-auth.ts"],"mappings":"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"}