@kb-labs/shared-command-kit 2.94.0 → 2.96.0

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { PluginContextV3, ManifestV3, PermissionSpec, JobDecl, CommandResult as CommandResult$1, HostContext, WSMessage, WSSender, WSInput } from '@kb-labs/plugin-contracts';
+import { PluginContextV3, ManifestV3, CliGroupMeta, CliCommandDecl, PermissionSpec, RestRouteDecl, WebhookHandlerDecl, WebhookAuthConfig, JobDecl, CommandResult as CommandResult$1, MutateIntent, ExecuteIntent, HostContext, WSMessage, WSSender, WSInput } from '@kb-labs/plugin-contracts';
 export { PluginContextV3 } from '@kb-labs/plugin-contracts';
 import { FlagSchemaDefinition as FlagSchemaDefinition$1, InferFlags } from './flags/index.js';
 export { ArrayFlagSchema, BaseFlagSchema, BooleanFlagSchema, FlagSchema, FlagSchemaWithInfer, FlagType, FlagValidationError, NumberFlagSchema, SafeValidationResult, StringFlagSchema, ValidationResult, defineFlags, validateFlags, validateFlagsSafe } from './flags/index.js';
 export { AnalyticsContext, AnalyticsEvents, createAnalyticsWrapper, trackEvent, withAnalytics } from './analytics/index.js';
 export { ErrorDefinition, ErrorDefinitions, FormatErrorOptions, FormattedError, PluginError, commonErrors, defineError, formatError } from './errors/index.js';
-export { getLLMTier, isCacheAvailable, isEmbeddingsAvailable, isLLMAvailable, isPlatformConfigured, isVectorStoreAvailable, trackAnalyticsEvent, useAnalytics, useCache, useConfig, useEmbeddings, useEnv, useLLM, useLogger, useLoggerWithContext, usePlatform, useStorage, useVectorStore } from './helpers/index.js';
+export { getLLMTier, isCacheAvailable, isDocumentDatabaseAvailable, isEmbeddingsAvailable, isKVStoreAvailable, isLLMAvailable, isPlatformConfigured, isVectorStoreAvailable, trackAnalyticsEvent, useAnalytics, useCache, useConfig, useDocumentDatabase, useEmbeddings, useEnv, useKVStore, useLLM, useLogger, useLoggerWithContext, useNotifications, usePlatform, useStorage, useVectorStore } from './helpers/index.js';
 import { z } from 'zod';
 export { CommandOutput } from '@kb-labs/shared-cli-ui';
 export { LLMTier, UseLLMOptions } from '@kb-labs/core-platform';
@@ -317,6 +317,213 @@ declare function defineCommandFlags<TFlags extends FlagSchemaDefinition>(flags:
     required?: boolean;
 }>;
 
+/**
+ * Manifest helpers — optional, additive utilities for reducing boilerplate.
+ *
+ * Manifests can always be written as plain TypeScript literal objects.
+ * These helpers exist purely to cut repetition in the CLI commands and REST
+ * routes sections, which are the two highest-density areas.
+ *
+ * Inspired by:
+ *   - Commander.js  → cmd() fluent builder for CLI commands
+ *   - Hono          → GET/POST/... standalone functions for HTTP routes
+ *   - Vite          → createManifest() thin wrapper for type safety
+ */
+
+/** Plugin identifier: must follow `@scope/name` format */
+type PluginId = `@${string}/${string}`;
+/** Semver string: `major.minor.patch[suffix]` */
+type SemVer = `${number}.${number}.${number}${string}`;
+/**
+ * Handler file reference.
+ * Must start with `./` and end with `.js` (optionally with `#exportName`).
+ * @example './commands/health.js'
+ * @example './commands/health.js#default'
+ */
+type HandlerRef = `./${string}.js` | `./${string}.js#${string}`;
+/** Base path for REST routes under the gateway. */
+type RestBase = `/v1/plugins/${string}`;
+/** Base path for WebSocket channels. */
+type WsBase = `/v1/ws/plugins/${string}`;
+type ManifestFlagDef = Record<string, {
+    type: 'string' | 'boolean' | 'number' | 'array';
+    alias?: string;
+    default?: unknown;
+    description?: string;
+    choices?: string[];
+    required?: boolean;
+}>;
+/**
+ * Fluent builder for a single CLI command declaration.
+ *
+ * Constructed via `cmd()` — not instantiated directly.
+ *
+ * @example
+ * ```ts
+ * cmd('workflow health', './commands/health.js#default', 'Check daemon health.')
+ *   .read()
+ *   .flags(healthFlags)
+ *   .examples(['kb workflow health', 'kb workflow health --json'])
+ * ```
+ */
+declare class CmdBuilder {
+    private readonly _state;
+    constructor(path: string, handler: string, describe: string);
+    /** operationType: 'read' — auto-injects --output, --limit, --offset */
+    read(): this;
+    /** operationType: 'mutate' — auto-injects --output, --dry-run, --yes */
+    mutate(): this;
+    /** operationType: 'execute' — auto-injects --output, --wait, --watch, --timeout, --yes */
+    execute(): this;
+    /** operationType: 'analyze' — auto-injects --output, --format, --stream */
+    analyze(): this;
+    /**
+     * Define command flags.
+     * Calls `defineCommandFlags()` internally — no need to wrap manually.
+     */
+    flags(def: ManifestFlagDef): this;
+    /** Long description shown in `--help` output. */
+    long(text: string): this;
+    /** Usage examples shown in `--help` output. */
+    examples(list: string[]): this;
+    /**
+     * Display category label.
+     * When using `group()`, the group's `category` is applied to commands
+     * that don't have their own category set.
+     */
+    category(cat: string): this;
+    /** Alternative full paths for this command. */
+    aliases(list: string[]): this;
+    /** Command-specific permissions (override plugin defaults). */
+    perms(spec: PermissionSpec): this;
+    /** Build the final `CliCommandDecl`. */
+    build(): CliCommandDecl;
+}
+/**
+ * Create a CLI command builder.
+ *
+ * Three required positional args cover the most repetitive fields.
+ * Everything else is chained: `.read()`, `.flags(def)`, `.examples([...])`.
+ *
+ * Eliminates:
+ *   - `operationType: 'read' as const`  → `.read()`
+ *   - `flags: defineCommandFlags(def)`  → `.flags(def)`
+ *   - repeated `category: 'X'`         → set once in `group()`
+ *
+ * @example
+ * ```ts
+ * cmd('workflow health', './commands/health.js#default', 'Check daemon health.')
+ *   .read()
+ *   .flags(healthFlags)
+ *   .examples(['kb workflow health'])
+ * ```
+ */
+declare function cmd(path: string, handler: HandlerRef, describe: string): CmdBuilder;
+/** Result of `group()` — passed to `mergeCliGroups()` or spread manually. */
+interface CliGroup {
+    meta: CliGroupMeta;
+    commands: CliCommandDecl[];
+}
+/**
+ * Group a set of commands under a shared `groupMeta` entry.
+ *
+ * If `meta.category` is provided, it is applied to every command inside
+ * that does not already have its own category set.
+ *
+ * @example
+ * ```ts
+ * const runsGroup = group(
+ *   { path: 'workflow runs', describe: 'Run management', category: 'Runs' },
+ *   [
+ *     cmd('workflow runs list', './commands/runs-list.js#default', 'List runs.').read().flags(runsListFlags),
+ *     cmd('workflow runs view', './commands/runs-view.js#default', 'View run details.').read().flags(runsViewFlags),
+ *   ]
+ * );
+ * ```
+ */
+declare function group(meta: {
+    path: string;
+    describe: string;
+    category?: string;
+}, cmds: Array<CmdBuilder | CliCommandDecl>): CliGroup;
+/**
+ * Merge multiple `CliGroup` results into a single `cli` section object.
+ *
+ * @example
+ * ```ts
+ * cli: mergeCliGroups(daemonGroup, jobsGroup, runsGroup),
+ * // → { commands: [...all commands], groupMeta: [...all group metas] }
+ * ```
+ */
+declare function mergeCliGroups(...groups: CliGroup[]): Required<ManifestV3>['cli'];
+type RouteOpts = Omit<RestRouteDecl, 'method' | 'path' | 'handler'>;
+/**
+ * Declare a GET route.
+ * @example GET(ROUTES.STATS, './rest/stats.js#default', { describe: 'Get stats' })
+ */
+declare const GET: (path: string, handler: HandlerRef, opts?: RouteOpts) => RestRouteDecl;
+/**
+ * Declare a POST route.
+ * @example POST(ROUTES.RUN, './rest/run.js#default', { describe: 'Run workflow' })
+ */
+declare const POST: (path: string, handler: HandlerRef, opts?: RouteOpts) => RestRouteDecl;
+/**
+ * Declare a PUT route.
+ */
+declare const PUT: (path: string, handler: HandlerRef, opts?: RouteOpts) => RestRouteDecl;
+/**
+ * Declare a PATCH route.
+ */
+declare const PATCH: (path: string, handler: HandlerRef, opts?: RouteOpts) => RestRouteDecl;
+/**
+ * Declare a DELETE route.
+ */
+declare const DELETE: (path: string, handler: HandlerRef, opts?: RouteOpts) => RestRouteDecl;
+type WebhookOpts = Omit<WebhookHandlerDecl, 'event' | 'handler'>;
+/**
+ * Declare a webhook handler in the plugin manifest.
+ *
+ * `auth` is required at the call site — the gateway will refuse to start if
+ * any webhook handler has no auth config.
+ *
+ * @example
+ * ```ts
+ * webhook('alert', './webhooks/alert.js#default', {
+ *   auth: { type: 'secret', header: 'X-Webhook-Secret' },
+ *   async: true,
+ * })
+ * ```
+ */
+declare function webhook(event: string, handler: HandlerRef, opts: WebhookOpts & {
+    auth: WebhookAuthConfig;
+}): WebhookHandlerDecl;
+/**
+ * Create a type-safe `ManifestV3`.
+ *
+ * Provides branded-type validation for `id` and `version`, and
+ * automatically injects `schema: 'kb.plugin/3'`.
+ * Everything else is a plain literal object — no fluent chain.
+ *
+ * Writing manifests as plain object literals without this wrapper
+ * is always valid.
+ *
+ * @example
+ * ```ts
+ * export const manifest = createManifest('@kb-labs/workflow', '1.0.0', {
+ *   display: { name: 'Workflow CLI' },
+ *   cli: mergeCliGroups(daemonGroup, runsGroup),
+ *   rest: {
+ *     basePath: WORKFLOW_BASE_PATH,
+ *     routes: [
+ *       GET(ROUTES.STATS, './rest/stats.js#default', { describe: 'Dashboard stats' }),
+ *     ],
+ *   },
+ *   permissions: pluginPermissions,
+ * });
+ * ```
+ */
+declare function createManifest(id: PluginId, version: SemVer, body: Omit<ManifestV3, 'id' | 'version' | 'schema'>): ManifestV3;
+
 /**
  * Schema Builders for KB Labs Plugins
  *
@@ -984,6 +1191,13 @@ interface CommandHandlerV3<TConfig = unknown, TInput = unknown, TResult = unknow
      * Execute the command
      */
     execute(context: PluginContextV3<TConfig>, input: TInput): Promise<CommandResult$1<TResult>> | CommandResult$1<TResult>;
+    /**
+     * Describe what the command *would* do without executing.
+     * Implement this to support `--dry-run` for mutate/execute commands.
+     * When present and `input.flags['dry-run']` is true, `defineCommand` calls
+     * this instead of `execute` and renders the intent output automatically.
+     */
+    intent?(context: PluginContextV3<TConfig>, input: TInput): Promise<MutateIntent | ExecuteIntent>;
     /**
      * Optional cleanup - called after execute completes
      */
@@ -1694,4 +1908,4 @@ interface CommandConfig<TFlags extends FlagSchemaDefinition$1 = FlagSchemaDefini
     formatter?: CommandFormatter<TConfig, InferFlags<TFlags>, TResult, TArgv, TEnv>;
 }
 
-export { type ActionDefinition, type ActionHandler, type CLIInput, type Command, type CommandConfig, type CommandDefinition, type CommandFormatter, type CommandGroup, type CommandHandler, type CommandHandlerV3, type CommandResult, type CommandStatus, type ConfigUpdates, type DefinedJob, type DestroyHandlerDefinition, type ErrorResult, FlagSchemaDefinition$1 as FlagSchemaDefinition, type Handler, type HandlerDefinition, InferFlags, type JobDefinition, type JobHandler, type JobInput, type LifecycleContext, MessageBuilder, MessageRouter, type RestInput, type ResultWith, type RouteDefinition, type RouteHandler, type SetupHandlerDefinition, type SetupResult, type SuccessResult, type SystemCommandConfig, type TypedSender, type WebSocketDefinition, type WebSocketHandler, type WebhookDefinition, type WebhookHandler, type WorkspaceConfig, array, artifactId, boolean, commandId, cwd, datetime, defineAction, defineCommand, defineCommandFlags, defineDestroyHandler, defineHandler, defineJob, defineManifest, defineMessage, defineRoute, defineSetupHandler, defineSystemCommand, defineSystemCommandGroup, defineWebSocket, defineWebhook, email, enumSchema, filePath, isCLIHost, isRESTHost, isWSHost, isWebhookHost, isWorkflowHost, json, nonNegativeInt, object, pluginId, positiveInt, schema, scopeId, text, url, uuid };
+export { type ActionDefinition, type ActionHandler, type CLIInput, type CliGroup, CmdBuilder, type Command, type CommandConfig, type CommandDefinition, type CommandFormatter, type CommandGroup, type CommandHandler, type CommandHandlerV3, type CommandResult, type CommandStatus, type ConfigUpdates, DELETE, type DefinedJob, type DestroyHandlerDefinition, type ErrorResult, FlagSchemaDefinition$1 as FlagSchemaDefinition, GET, type Handler, type HandlerDefinition, type HandlerRef, InferFlags, type JobDefinition, type JobHandler, type JobInput, type LifecycleContext, MessageBuilder, MessageRouter, PATCH, POST, PUT, type PluginId, type RestBase, type RestInput, type ResultWith, type RouteDefinition, type RouteHandler, type SemVer, type SetupHandlerDefinition, type SetupResult, type SuccessResult, type SystemCommandConfig, type TypedSender, type WebSocketDefinition, type WebSocketHandler, type WebhookDefinition, type WebhookHandler, type WorkspaceConfig, type WsBase, array, artifactId, boolean, cmd, commandId, createManifest, cwd, datetime, defineAction, defineCommand, defineCommandFlags, defineDestroyHandler, defineHandler, defineJob, defineManifest, defineMessage, defineRoute, defineSetupHandler, defineSystemCommand, defineSystemCommandGroup, defineWebSocket, defineWebhook, email, enumSchema, filePath, group, isCLIHost, isRESTHost, isWSHost, isWebhookHost, isWorkflowHost, json, mergeCliGroups, nonNegativeInt, object, pluginId, positiveInt, schema, scopeId, text, url, uuid, webhook };

package/dist/index.js

@@ -659,12 +659,34 @@ async function useConfig(productId, profileId) {
   if (!effectiveProductId) {
     return void 0;
   }
+  const g = globalThis;
+  const rawConfig = g.__KB_EFFECTIVE_CONFIG__ ?? g.__KB_RAW_CONFIG__;
+  if (rawConfig) {
+    return selectProductSection(rawConfig, effectiveProductId, profileId);
+  }
   const { usePlatform: usePlatform2 } = await Promise.resolve().then(() => (init_use_platform(), use_platform_exports));
   const platform = usePlatform2();
-  if (!platform) {
-    return void 0;
+  if (platform?.config) {
+    return await platform.config.getConfig(effectiveProductId, profileId);
+  }
+  return void 0;
+}
+function selectProductSection(rawConfig, productId, profileId) {
+  const effectiveProfileId = profileId ?? process.env.KB_PROFILE ?? "default";
+  const profilesField = rawConfig.profiles;
+  if (Array.isArray(profilesField)) {
+    const profiles = profilesField;
+    const profile = profiles.find((p) => p.id === effectiveProfileId) ?? profiles[0];
+    if (profile?.products?.[productId] !== void 0) {
+      return profile.products[productId];
+    }
+  }
+  const legacyKeyMap = { mind: "knowledge" };
+  const legacyKey = legacyKeyMap[productId] ?? productId;
+  if (rawConfig[legacyKey] !== void 0) {
+    return rawConfig[legacyKey];
   }
-  return await platform.config.getConfig(effectiveProductId, profileId);
+  return void 0;
 }
 
 // src/helpers/use-logger.ts
@@ -878,6 +900,33 @@ function isCacheAvailable() {
   const cache = useCache();
   return !!cache;
 }
+
+// src/helpers/use-document-database.ts
+init_use_platform();
+function useDocumentDatabase() {
+  const platform = usePlatform();
+  return platform.documentDatabase;
+}
+function isDocumentDatabaseAvailable() {
+  return useDocumentDatabase() !== void 0;
+}
+
+// src/helpers/use-kv-store.ts
+init_use_platform();
+function useKVStore() {
+  const platform = usePlatform();
+  return platform.kvStore;
+}
+function isKVStoreAvailable() {
+  return useKVStore() !== void 0;
+}
+
+// src/helpers/use-notifications.ts
+init_use_platform();
+function useNotifications() {
+  const platform = usePlatform();
+  return platform.notifier;
+}
 function useEnv(key) {
   const runtime = runtimeContext.getStore();
   if (runtime?.env) {
@@ -984,6 +1033,142 @@ function defineCommandFlags(flags) {
     ...flag.required !== void 0 && { required: flag.required }
   }));
 }
+
+// src/manifest-builder.ts
+var CmdBuilder = class {
+  _state;
+  constructor(path2, handler, describe) {
+    this._state = { path: path2, handler, describe };
+  }
+  /** operationType: 'read' — auto-injects --output, --limit, --offset */
+  read() {
+    this._state.operationType = "read";
+    return this;
+  }
+  /** operationType: 'mutate' — auto-injects --output, --dry-run, --yes */
+  mutate() {
+    this._state.operationType = "mutate";
+    return this;
+  }
+  /** operationType: 'execute' — auto-injects --output, --wait, --watch, --timeout, --yes */
+  execute() {
+    this._state.operationType = "execute";
+    return this;
+  }
+  /** operationType: 'analyze' — auto-injects --output, --format, --stream */
+  analyze() {
+    this._state.operationType = "analyze";
+    return this;
+  }
+  /**
+   * Define command flags.
+   * Calls `defineCommandFlags()` internally — no need to wrap manually.
+   */
+  flags(def) {
+    this._state.flags = defineCommandFlags(def);
+    return this;
+  }
+  /** Long description shown in `--help` output. */
+  long(text2) {
+    this._state.longDescription = text2;
+    return this;
+  }
+  /** Usage examples shown in `--help` output. */
+  examples(list) {
+    this._state.examples = list;
+    return this;
+  }
+  /**
+   * Display category label.
+   * When using `group()`, the group's `category` is applied to commands
+   * that don't have their own category set.
+   */
+  category(cat) {
+    this._state.category = cat;
+    return this;
+  }
+  /** Alternative full paths for this command. */
+  aliases(list) {
+    this._state.aliases = list;
+    return this;
+  }
+  /** Command-specific permissions (override plugin defaults). */
+  perms(spec) {
+    this._state.permissions = spec;
+    return this;
+  }
+  /** Build the final `CliCommandDecl`. */
+  build() {
+    const decl = {
+      path: this._state.path,
+      handler: this._state.handler,
+      describe: this._state.describe
+    };
+    if (this._state.operationType !== void 0) {
+      decl.operationType = this._state.operationType;
+    }
+    if (this._state.longDescription !== void 0) {
+      decl.longDescription = this._state.longDescription;
+    }
+    if (this._state.flags !== void 0) {
+      decl.flags = this._state.flags;
+    }
+    if (this._state.examples !== void 0) {
+      decl.examples = this._state.examples;
+    }
+    if (this._state.category !== void 0) {
+      decl.category = this._state.category;
+    }
+    if (this._state.aliases !== void 0) {
+      decl.aliases = this._state.aliases;
+    }
+    if (this._state.permissions !== void 0) {
+      decl.permissions = this._state.permissions;
+    }
+    return decl;
+  }
+};
+function cmd(path2, handler, describe) {
+  return new CmdBuilder(path2, handler, describe);
+}
+function group(meta, cmds) {
+  const commands = cmds.map((c) => {
+    const decl = c instanceof CmdBuilder ? c.build() : c;
+    if (meta.category !== void 0 && decl.category === void 0) {
+      return { ...decl, category: meta.category };
+    }
+    return decl;
+  });
+  return {
+    meta: { path: meta.path, describe: meta.describe },
+    commands
+  };
+}
+function mergeCliGroups(...groups) {
+  return {
+    commands: groups.flatMap((g) => g.commands),
+    groupMeta: groups.map((g) => g.meta)
+  };
+}
+function routeHelper(method, path2, handler, opts) {
+  return { method, path: path2, handler, ...opts };
+}
+var GET = (path2, handler, opts) => routeHelper("GET", path2, handler, opts);
+var POST = (path2, handler, opts) => routeHelper("POST", path2, handler, opts);
+var PUT = (path2, handler, opts) => routeHelper("PUT", path2, handler, opts);
+var PATCH = (path2, handler, opts) => routeHelper("PATCH", path2, handler, opts);
+var DELETE = (path2, handler, opts) => routeHelper("DELETE", path2, handler, opts);
+function webhook(event, handler, opts) {
+  return { event, handler, ...opts };
+}
+function createManifest(id, version, body) {
+  return {
+    schema: "kb.plugin/3",
+    id,
+    version,
+    ...body
+  };
+}
 function cwd() {
   return z.string().optional().describe("Current working directory path");
 }
@@ -1313,11 +1498,35 @@ function defineCommand(definition) {
           `Command ${definition.id} can only run in CLI or workflow host (current: ${context.host})`
         );
       }
+      const flags = input?.flags;
+      if (flags?.["dry-run"] && typeof definition.handler.intent === "function") {
+        return (async () => {
+          const intent = await definition.handler.intent(context, input);
+          renderDryRunIntent(context.ui, intent);
+          return { exitCode: 0, result: intent };
+        })();
+      }
       return definition.handler.execute(context, input);
     },
     cleanup: definition.handler.cleanup
   };
 }
+function renderDryRunIntent(ui, intent) {
+  if ("operations" in intent) {
+    ui.info(`Dry-run: ${intent.summary}`, {
+      sections: [{
+        header: "Operations",
+        items: intent.operations.map((op) => {
+          const detail = op.details ? ` \u2014 ${JSON.stringify(op.details)}` : "";
+          return `${op.type.toUpperCase()} ${op.resource}${detail}`;
+        })
+      }]
+    });
+  } else {
+    const hint = intent.estimatedDurationMs ? ` (~${Math.round(intent.estimatedDurationMs / 1e3)}s)` : "";
+    ui.info(`Dry-run: ${intent.summary}${hint}`);
+  }
+}
 function isCLIHost(hostContext) {
   return hostContext.host === "cli";
 }
@@ -1556,6 +1765,6 @@ var MessageRouter = class {
   }
 };
 
-export { FlagValidationError, MessageBuilder, MessageRouter, PluginError, array, artifactId, boolean, commandId, commonErrors, createAnalyticsWrapper, cwd, datetime, defineAction, defineCommand, defineCommandFlags, defineDestroyHandler, defineError, defineFlags, defineHandler, defineJob, defineManifest, defineMessage, defineRoute, defineSetupHandler, defineSystemCommand, defineSystemCommandGroup, defineWebSocket, defineWebhook, email, enumSchema, filePath, formatError, getLLMTier, isCLIHost, isCacheAvailable, isEmbeddingsAvailable, isLLMAvailable, isPlatformConfigured, isRESTHost, isVectorStoreAvailable, isWSHost, isWebhookHost, isWorkflowHost, json, nonNegativeInt, object, pluginId, positiveInt, schema, scopeId, text, trackAnalyticsEvent, trackEvent, url, useAnalytics, useCache, useConfig, useEmbeddings, useEnv, useLLM, useLogger, useLoggerWithContext, usePlatform, useStorage, useVectorStore, uuid, validateFlags, validateFlagsSafe, withAnalytics };
+export { CmdBuilder, DELETE, FlagValidationError, GET, MessageBuilder, MessageRouter, PATCH, POST, PUT, PluginError, array, artifactId, boolean, cmd, commandId, commonErrors, createAnalyticsWrapper, createManifest, cwd, datetime, defineAction, defineCommand, defineCommandFlags, defineDestroyHandler, defineError, defineFlags, defineHandler, defineJob, defineManifest, defineMessage, defineRoute, defineSetupHandler, defineSystemCommand, defineSystemCommandGroup, defineWebSocket, defineWebhook, email, enumSchema, filePath, formatError, getLLMTier, group, isCLIHost, isCacheAvailable, isDocumentDatabaseAvailable, isEmbeddingsAvailable, isKVStoreAvailable, isLLMAvailable, isPlatformConfigured, isRESTHost, isVectorStoreAvailable, isWSHost, isWebhookHost, isWorkflowHost, json, mergeCliGroups, nonNegativeInt, object, pluginId, positiveInt, schema, scopeId, text, trackAnalyticsEvent, trackEvent, url, useAnalytics, useCache, useConfig, useDocumentDatabase, useEmbeddings, useEnv, useKVStore, useLLM, useLogger, useLoggerWithContext, useNotifications, usePlatform, useStorage, useVectorStore, uuid, validateFlags, validateFlagsSafe, webhook, withAnalytics };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map