@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/plugin/index.d.ts

@@ -0,0 +1,458 @@
+import { T as Tool, L as AgentMiddleware, c5 as PromptSection } from '../instance-BqV2D5pc.js';
+import { ZodType } from 'zod';
+import { Jiti } from 'jiti';
+import '../types-C_LCeYNg.js';
+import 'ai';
+import '../types-RSCv7nQ4.js';
+import '../types-CQaXbRsS.js';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
+import '../llm-error-D93FNNLY.js';
+
+/**
+ * PluginEventBus — string-keyed pub/sub for inter-plugin communication.
+ *
+ * Channel names are namespaced by convention:
+ * "finance:transaction-created", "crm:contact-updated".
+ */
+/** Remove a previously registered listener. */
+type PluginUnsubscribe = () => void;
+/** Listener function for a specific channel. */
+type PluginEventHandler = (data: unknown) => void;
+/**
+ * Minimal event bus interface. Plugins depend only on this.
+ */
+interface PluginEventBusAPI {
+    emit(channel: string, data: unknown): void;
+    on(channel: string, handler: PluginEventHandler): PluginUnsubscribe;
+}
+/**
+ * In-process event bus. Dispatches synchronously.
+ * Listener errors are caught silently.
+ */
+declare class PluginEventBus implements PluginEventBusAPI {
+    private readonly channels;
+    emit(channel: string, data: unknown): void;
+    on(channel: string, handler: PluginEventHandler): PluginUnsubscribe;
+    /** Number of active channels. */
+    get size(): number;
+    /** Remove all listeners. */
+    clear(): void;
+}
+
+/**
+ * Plugin types — contracts for the extension system.
+ *
+ * Plugins contribute tools, middleware, commands, prompt sections,
+ * and lifecycle hooks to an agent without coupling to a specific host.
+ */
+
+/** Static metadata about a plugin (from package.json or inline). */
+interface PluginCompatibility {
+    /** Expected plugin API version supported by the host (exact match). */
+    apiVersion?: string;
+    /** Supported Node.js version range (supports exact or comparator syntax). */
+    node?: string;
+}
+/** Host-readable capability tags such as "workspace", "session", or "network". */
+type PluginCapabilityTag = string;
+/**
+ * Static surface contract for a plugin.
+ *
+ * This keeps the server/plugin boundary explicit: plugin behavior is headless
+ * by default, and any future UI surface must remain a separate client concern.
+ */
+interface PluginSurfaceContract {
+    tools?: boolean;
+    middleware?: boolean;
+    commands?: boolean;
+    promptSections?: boolean;
+    lifecycle?: boolean;
+    ui?: "none" | "separate-client-extension";
+}
+interface PluginManifest {
+    /** Unique plugin identifier (e.g. "brave-search", "finance") */
+    id: string;
+    /** Human-readable display name */
+    name?: string;
+    /** Short description */
+    description?: string;
+    /** SemVer string */
+    version?: string;
+    /** Compatibility requirements validated by the host at load time. */
+    compatibility?: PluginCompatibility;
+    /** Host-readable business capability tags. */
+    capabilities?: PluginCapabilityTag[];
+    /** Explicit contract for which host-owned surfaces this plugin contributes to. */
+    surfaces?: PluginSurfaceContract;
+}
+/**
+ * Host-readable metadata for a plugin command.
+ *
+ * This is the sanctioned way to enrich command discovery and routing without
+ * coupling plugins to a specific renderer or UI widget system.
+ */
+interface PluginCommandMetadata {
+    /** Grouping hint for help views, palettes, and command inventories. */
+    category?: string;
+    /** Short argument hint shown in usage/help surfaces. */
+    argsHint?: string;
+    /** Host-readable capability tags such as "workspace", "session", or "network". */
+    capabilities?: PluginCapabilityTag[];
+}
+/**
+ * A user-facing command registered by a plugin.
+ *
+ * Commands are intentionally host-surfaced, not renderer-owned UI. Plugins
+ * should return results and metadata here instead of trying to reach into TUI
+ * or web implementation details.
+ */
+interface PluginCommand {
+    /** Command name (without leading slash) */
+    name: string;
+    /** Optional aliases */
+    alias?: string[];
+    /** One-line description shown in help */
+    summary: string;
+    /** Execute the command. Return the text to display, or null for silent. */
+    execute: (args: string) => Promise<string | null>;
+    /** Optional host-readable metadata for richer discovery and routing. */
+    metadata?: PluginCommandMetadata;
+}
+type PluginSettingsSchema<T = unknown> = ZodType<T>;
+interface PluginSettingsDefinition<T = unknown> {
+    /** Settings namespace. Defaults to the plugin ID. */
+    namespace?: string;
+    /** Whether missing settings are allowed. Defaults to true. */
+    optional?: boolean;
+    /** Zod schema used to validate the resolved settings object. */
+    schema: PluginSettingsSchema<T>;
+}
+/** Namespace-isolated config access. The host injects the implementation. */
+interface PluginSettingsProvider {
+    /**
+     * Read the config value for a given namespace.
+     *
+     * @param namespace  Plugin's config key (e.g. "brave-search")
+     * @returns The config object, or undefined if not configured.
+     */
+    get<T = unknown>(namespace: string): T | undefined;
+    /**
+     * Read and validate a namespace with a schema.
+     *
+     * Returns undefined when the namespace is not configured.
+     */
+    parse<T>(namespace: string, schema: PluginSettingsSchema<T>): T | undefined;
+    /**
+     * Read and validate a namespace with a schema.
+     *
+     * Throws when the namespace is missing or invalid.
+     */
+    require<T>(namespace: string, schema: PluginSettingsSchema<T>): T;
+}
+/** Session lifecycle hooks a plugin can register. */
+interface PluginLifecycleHooks {
+    activate?: (ctx: PluginSessionContext) => Promise<void> | void;
+    deactivate?: () => Promise<void> | void;
+}
+/** Context available during plugin activation. */
+interface PluginSessionContext {
+    /** Agent's working directory */
+    cwd: string;
+    /** Session ID (if session-based) */
+    sessionId?: string;
+}
+/** The API surface passed to a plugin's entry function. */
+interface PluginContext {
+    /** Working directory of the agent (project root) */
+    cwd: string;
+    /** Plugin's own manifest (id, name, version). Read-only. */
+    manifest: Readonly<PluginManifest>;
+    /** Register a tool the LLM can call */
+    addTool(tool: Tool.AnyInfo): void;
+    /** Register middleware (model hooks, tool guards, prompt sections) */
+    addMiddleware(mw: AgentMiddleware): void;
+    /** Register a user-facing command (host-dependent) */
+    addCommand(cmd: PluginCommand): void;
+    /** Add a dynamic prompt section injected at system-prompt build time. */
+    addPromptSection(section: PromptSection): void;
+    /** Inter-plugin event bus (string-keyed pub/sub). */
+    events: PluginEventBus;
+    /** Plugin-namespaced settings from the host. */
+    settings: PluginSettingsProvider;
+    /** Register an activation hook (fires when the agent session starts). */
+    onActivate(fn: (ctx: PluginSessionContext) => Promise<void> | void): void;
+    /** Register a deactivation hook (fires when the agent session ends). */
+    onDeactivate(fn: () => Promise<void> | void): void;
+}
+/** The function shape a plugin file must default-export. */
+type PluginInit = (ctx: PluginContext) => void | Promise<void>;
+/** Aggregated contributions from all loaded plugins. */
+interface PluginContributions {
+    /** Tools to add to the agent's tool set */
+    tools: Tool.AnyInfo[];
+    /** Middleware to prepend to the agent's middleware stack */
+    middleware: AgentMiddleware[];
+    /** User-facing commands (host-dependent surfacing) */
+    commands: PluginCommand[];
+    /** Dynamic prompt sections */
+    promptSections: PromptSection[];
+    /** Loader / plugin errors (non-fatal — the rest of the system keeps working) */
+    errors: Array<{
+        pluginId: string;
+        error: string;
+    }>;
+}
+
+/**
+ * Plugin settings — namespace-isolated layered configuration.
+ */
+
+/** Settings provider that always returns undefined. */
+declare class NullSettings implements PluginSettingsProvider {
+    get<T = unknown>(_namespace: string): T | undefined;
+    parse<T>(_namespace: string, _schema: PluginSettingsSchema<T>): T | undefined;
+    require<T>(namespace: string, _schema: PluginSettingsSchema<T>): T;
+}
+/** Settings provider backed by a plain object. Top-level keys are plugin namespaces. */
+declare class StaticSettings implements PluginSettingsProvider {
+    private readonly data;
+    constructor(data: Record<string, unknown>);
+    get<T = unknown>(namespace: string): T | undefined;
+    parse<T>(namespace: string, schema: PluginSettingsSchema<T>): T | undefined;
+    require<T>(namespace: string, schema: PluginSettingsSchema<T>): T;
+}
+/** Merges multiple settings sources in priority order (later layers win). */
+declare class LayeredSettings implements PluginSettingsProvider {
+    private readonly layers;
+    constructor(layers: PluginSettingsProvider[]);
+    get<T = unknown>(namespace: string): T | undefined;
+    parse<T>(namespace: string, schema: PluginSettingsSchema<T>): T | undefined;
+    require<T>(namespace: string, schema: PluginSettingsSchema<T>): T;
+}
+/** Wraps a provider with validated overrides for specific namespaces. */
+declare class ValidatedSettings implements PluginSettingsProvider {
+    private readonly base;
+    private readonly overrides;
+    constructor(base: PluginSettingsProvider, overrides: Record<string, unknown>);
+    get<T = unknown>(namespace: string): T | undefined;
+    parse<T>(namespace: string, schema: PluginSettingsSchema<T>): T | undefined;
+    require<T>(namespace: string, schema: PluginSettingsSchema<T>): T;
+}
+
+/**
+ * Plugin loader — filesystem discovery and dynamic import via jiti.
+ *
+ * Scans `.cuylabs/plugins/` and explicit paths for plugin entries.
+ * Files starting with `_` are ignored. Each plugin must default-export
+ * a PluginInit function.
+ *
+ * Uses jiti for TypeScript-native loading — users drop raw `.ts` files
+ * and they work without a build step. Transpiled output is cached to
+ * disk for fast subsequent loads.
+ *
+ * Framework packages (`@cuylabs/*`) are auto-aliased so plugins can
+ * `import { ... } from "@cuylabs/agent-core"` without any user config.
+ * Resolution uses `import.meta.resolve` (ESM standard) with a monorepo
+ * workspace fallback for development.
+ */
+
+/** Options for configuring the plugin loader's jiti instance. */
+interface PluginLoaderOptions {
+    /** Extra module aliases (e.g. `{ "@my-lib": "./src/lib" }`). */
+    alias?: Record<string, string>;
+    /** Modules to skip transforming (already compiled). */
+    nativeModules?: string[];
+    /** Enable source maps in error stacks (default: true). */
+    sourceMaps?: boolean;
+    /** Enable jiti debug logging (default: false). */
+    debug?: boolean;
+    /**
+     * Disable automatic `@cuylabs/*` alias resolution.
+     * When false, plugins must resolve framework packages on their own.
+     * @default true
+     */
+    autoAlias?: boolean;
+}
+/**
+ * Auto-resolve `@cuylabs/*` packages to their filesystem paths.
+ *
+ * Uses two strategies in order:
+ * 1. `import.meta.resolve(specifier)` — standard ESM resolution.
+ *    Works when packages are in node_modules (installed via npm/pnpm).
+ * 2. Monorepo workspace fallback — walk up from this file to find
+ *    the workspace root, then check `packages/<name>/dist/index.js`.
+ *
+ * Results are cached for the process lifetime.
+ */
+declare function resolveFrameworkAliases(): Record<string, string>;
+/** Reset cached framework aliases (for testing). */
+declare function resetFrameworkAliases(): void;
+/** Get or create a shared jiti instance for plugin loading. */
+declare function getPluginLoader(options?: PluginLoaderOptions): Jiti;
+/** Reset the shared jiti instance (for testing). */
+declare function resetPluginLoader(): void;
+/** A discovered plugin file with its resolved entry path and manifest. */
+interface DiscoveredPlugin {
+    entryPath: string;
+    manifest: PluginManifest;
+}
+/** Discover plugin files on disk from convention dir and explicit paths. */
+declare function discoverPlugins(cwd: string, extraPaths?: string[]): Promise<DiscoveredPlugin[]>;
+/** Dynamically import a plugin file and extract its init function. */
+declare function loadPluginModule(entryPath: string, options?: PluginLoaderOptions): Promise<PluginInit>;
+
+/**
+ * Declarative plugin authoring — `definePlugin()`.
+ *
+ * Converts a static plugin definition into a `PluginInit` function.
+ * The registry and imperative layer stay unchanged; this is sugar
+ * that makes plugins inspectable, type-safe, and easier to author.
+ */
+
+/** Declarative plugin definition passed to `definePlugin()`. */
+interface PluginDefinition {
+    /** Unique plugin identifier. */
+    id: string;
+    /** Human-readable display name. */
+    name?: string;
+    /** Short description. */
+    description?: string;
+    /** SemVer string. */
+    version?: string;
+    /** Host/runtime compatibility validated before the plugin is committed. */
+    compatibility?: PluginCompatibility;
+    /** Host-readable business capability tags for catalogs and inventories. */
+    capabilities?: PluginCapabilityTag[];
+    /** Explicit contract for the host-owned surfaces this plugin contributes to. */
+    surfaces?: PluginSurfaceContract;
+    /** Optional settings schema to validate before the plugin is committed. */
+    settings?: PluginSettingsDefinition;
+    /** Tools the LLM can call. Statically declared — inspectable without execution. */
+    tools?: Tool.AnyInfo[];
+    /** Middleware hooks (model I/O, tool guards, prompt sections). */
+    middleware?: AgentMiddleware[];
+    /** User-facing commands. */
+    commands?: PluginCommand[];
+    /** Dynamic prompt sections injected at system-prompt build time. */
+    promptSections?: PromptSection[];
+    /**
+     * Imperative activation hook — runs when the agent session starts.
+     * Use for dynamic setup that can't be expressed declaratively
+     * (starting servers, loading config, managing state).
+     */
+    activate?: (ctx: PluginActivateContext) => Promise<void> | void;
+    /**
+     * Imperative deactivation hook — runs when the agent session ends.
+     */
+    deactivate?: () => Promise<void> | void;
+    /**
+     * Full imperative escape hatch — runs during plugin loading.
+     * Receives the raw PluginContext for anything the declarative
+     * fields can't express. Runs after all declarative contributions
+     * have been registered.
+     */
+    setup?: (ctx: PluginContext) => void | Promise<void>;
+}
+/** Context passed to the declarative `activate` hook. */
+interface PluginActivateContext extends PluginSessionContext {
+    /** The plugin's own event bus. */
+    events: PluginContext["events"];
+    /** The plugin's settings provider. */
+    settings: PluginContext["settings"];
+}
+/**
+ * Create a plugin from a declarative definition.
+ *
+ * Returns a `PluginInit` function that the registry executes normally.
+ * The definition object is attached as `init.__definition` so the
+ * registry can inspect it without running the plugin.
+ */
+declare function definePlugin(def: PluginDefinition): PluginInit;
+/** A PluginInit created by `definePlugin()` — carries the static definition. */
+interface DefinePluginInit extends PluginInit {
+    __definition: PluginDefinition;
+}
+/** Type guard: check if a PluginInit was created by `definePlugin()`. */
+declare function isDefinedPlugin(init: PluginInit): init is DefinePluginInit;
+
+/**
+ * PluginRegistry — orchestrates the full plugin lifecycle.
+ *
+ * `loadAll` → `activate` → (agent runs) → `deactivate`.
+ * Owns the shared PluginEventBus and wires isolated PluginContext per plugin.
+ */
+
+interface PluginRegistryCompatibilityOptions {
+    /** Supported plugin API version (exact match). */
+    apiVersion?: string;
+    /** Runtime Node.js version. Defaults to the current process version. */
+    nodeVersion?: string;
+}
+interface PluginRegistryTimeoutOptions {
+    /** Maximum time allowed for a plugin init function. */
+    load?: number | false;
+    /** Maximum time allowed per activation hook. */
+    activate?: number | false;
+    /** Maximum time allowed per deactivation hook. */
+    deactivate?: number | false;
+}
+interface PluginRegistryOptions {
+    /** Settings provider. Defaults to NullSettings (no config). */
+    settings?: PluginSettingsProvider;
+    /** Shared event bus. A fresh one is created if omitted. */
+    events?: PluginEventBus;
+    /** Options for the jiti-powered plugin loader. */
+    loader?: PluginLoaderOptions;
+    /** Host compatibility context used to reject incompatible plugins. */
+    compatibility?: PluginRegistryCompatibilityOptions;
+    /** Timeouts applied to init and lifecycle hooks. */
+    timeouts?: PluginRegistryTimeoutOptions;
+}
+declare class PluginRegistry {
+    private readonly settings;
+    private readonly eventBus;
+    private readonly loaderOptions;
+    private readonly compatibilityContext;
+    private readonly timeouts;
+    private readonly plugins;
+    private readonly pluginIds;
+    private readonly commandOwners;
+    private readonly commandTokens;
+    private readonly _contributions;
+    private activated;
+    private activeSessionContext?;
+    constructor(options?: PluginRegistryOptions);
+    /** The shared event bus wired to all loaded plugins. */
+    get events(): PluginEventBus;
+    /** Read-only view of everything plugins have contributed. */
+    get contributions(): Readonly<PluginContributions>;
+    /** Number of successfully loaded plugins. */
+    get pluginCount(): number;
+    /** Get the static definition for a plugin (if it used `definePlugin()`). */
+    getDefinition(pluginId: string): PluginDefinition | undefined;
+    /** Get all static definitions (only for declarative plugins). */
+    get definitions(): ReadonlyArray<Readonly<PluginDefinition>>;
+    /** Get the plugin ID that contributed a command. */
+    getCommandOwner(command: PluginCommand): string | undefined;
+    /** Record a host-level plugin error without throwing. */
+    recordError(pluginId: string, error: string): void;
+    /** Discover, load, and execute all plugins. */
+    loadAll(cwd: string, extraPaths?: string[]): Promise<void>;
+    /** Load a single plugin from its init function (programmatic / tests). */
+    loadOne(init: PluginInit, manifest: PluginManifest, cwd: string, entryPath?: string): Promise<void>;
+    /** Fire `onActivate` hooks sequentially in load order. */
+    activate(ctx: PluginSessionContext): Promise<void>;
+    /** Fire `onDeactivate` hooks in reverse load order. */
+    deactivate(): Promise<void>;
+    private executePlugin;
+    private resolvePluginSettings;
+    private findCommandConflict;
+    private checkCommandTokenConflict;
+    private commitPlugin;
+    private runActivateHooks;
+    private runDeactivateHooks;
+}
+
+export { type DefinePluginInit, type DiscoveredPlugin, LayeredSettings, NullSettings, type PluginActivateContext, type PluginCapabilityTag, type PluginCommand, type PluginCommandMetadata, type PluginCompatibility, type PluginContext, type PluginContributions, type PluginDefinition, PluginEventBus, type PluginEventBusAPI, type PluginEventHandler, type PluginInit, type PluginLifecycleHooks, type PluginLoaderOptions, type PluginManifest, PluginRegistry, type PluginRegistryCompatibilityOptions, type PluginRegistryOptions, type PluginRegistryTimeoutOptions, type PluginSessionContext, type PluginSettingsDefinition, type PluginSettingsProvider, type PluginSettingsSchema, type PluginSurfaceContract, type PluginUnsubscribe, StaticSettings, ValidatedSettings, definePlugin, discoverPlugins, getPluginLoader, isDefinedPlugin, loadPluginModule, resetFrameworkAliases, resetPluginLoader, resolveFrameworkAliases };

package/dist/plugin/index.js

@@ -0,0 +1,32 @@
+import {
+  LayeredSettings,
+  NullSettings,
+  PluginEventBus,
+  PluginRegistry,
+  StaticSettings,
+  ValidatedSettings,
+  definePlugin,
+  discoverPlugins,
+  getPluginLoader,
+  isDefinedPlugin,
+  loadPluginModule,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases
+} from "../chunk-QAL3OMI3.js";
+export {
+  LayeredSettings,
+  NullSettings,
+  PluginEventBus,
+  PluginRegistry,
+  StaticSettings,
+  ValidatedSettings,
+  definePlugin,
+  discoverPlugins,
+  getPluginLoader,
+  isDefinedPlugin,
+  loadPluginModule,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases
+};

package/dist/profiles/index.d.ts

@@ -0,0 +1,55 @@
+import { T as Tool, c2 as Profile, aa as AppliedProfile } from '../instance-BqV2D5pc.js';
+import '../types-C_LCeYNg.js';
+import 'ai';
+import '../types-RSCv7nQ4.js';
+import 'zod';
+import '../types-CQaXbRsS.js';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
+import '../llm-error-D93FNNLY.js';
+
+/**
+ * Filter tools using profile allow/deny patterns.
+ *
+ * Explicit allow matches win over deny matches. This lets profiles define a
+ * broad deny rule like `"*"` and then carve out a safe allow-list.
+ */
+declare function filterTools(tools: Tool.AnyInfo[], options: {
+    allow?: string[];
+    deny?: string[];
+}): Tool.AnyInfo[];
+
+/**
+ * Apply a profile to available tools and a parent system prompt.
+ */
+declare function applyProfile(profile: Profile, availableTools: Tool.AnyInfo[], baseSystemPrompt?: string): AppliedProfile;
+/**
+ * Merge multiple profiles. Later profiles override earlier scalar values.
+ */
+declare function mergeProfiles(...profiles: Profile[]): Profile;
+/**
+ * Create a custom profile with sensible defaults.
+ */
+declare function createProfile(options: Partial<Profile> & {
+    name: string;
+}): Profile;
+
+declare const explore: Profile;
+declare const plan: Profile;
+declare const review: Profile;
+declare const quick: Profile;
+declare const careful: Profile;
+declare const code: Profile;
+declare const watch: Profile;
+declare const Profiles: {
+    readonly explore: Profile;
+    readonly plan: Profile;
+    readonly review: Profile;
+    readonly quick: Profile;
+    readonly careful: Profile;
+    readonly code: Profile;
+    readonly watch: Profile;
+};
+
+export { AppliedProfile, Profile, Profiles, applyProfile, careful, code, createProfile, explore, filterTools, mergeProfiles, plan, quick, review, watch };

package/dist/profiles/index.js

@@ -0,0 +1,30 @@
+import {
+  applyProfile,
+  createProfile,
+  filterTools,
+  mergeProfiles
+} from "../chunk-TIHPYVAJ.js";
+import {
+  Profiles,
+  careful,
+  code,
+  explore,
+  plan,
+  quick,
+  review,
+  watch
+} from "../chunk-6HZBHFOL.js";
+export {
+  Profiles,
+  applyProfile,
+  careful,
+  code,
+  createProfile,
+  explore,
+  filterTools,
+  mergeProfiles,
+  plan,
+  quick,
+  review,
+  watch
+};

package/dist/prompt/index.d.ts

@@ -1,18 +1,14 @@
-import { c as ModelFamily, g as EnvironmentInfo, I as InstructionFile } from '../runner-e2YRcUoX.js';
-export { a as PromptBuildContext, P as PromptConfig, b as PromptSection } from '../runner-e2YRcUoX.js';
+import { bM as ModelFamily, b6 as EnvironmentInfo, bq as InstructionFile } from '../instance-BqV2D5pc.js';
+export { c3 as PromptBuildContext, P as PromptBuilder, c4 as PromptConfig, c5 as PromptSection, cq as SkillConfig, dG as createPromptBuilder } from '../instance-BqV2D5pc.js';
 import { LanguageModel } from 'ai';
-export { P as PromptBuilder, c as createPromptBuilder } from '../builder-UpOWQMW3.js';
-export { d as SkillConfig } from '../types-BfNpU8NS.js';
-import '@ai-sdk/provider-utils';
-import '../events-CE72w8W4.js';
-import '../messages-BYWGn8TY.js';
-import '../types-CQL-SvTn.js';
-import '../tool-DLXAR9Ce.js';
-import '../types-CHiPh8U2.js';
-import '../tool-BHbyUAy3.js';
+import '../types-C_LCeYNg.js';
+import '../types-RSCv7nQ4.js';
 import 'zod';
 import '../types-CQaXbRsS.js';
-import '../registry-DwYqsQkX.js';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
+import '../llm-error-D93FNNLY.js';
 
 /**
  * Prompt Templates — Base system prompts per model family

package/dist/prompt/index.js

@@ -19,8 +19,9 @@ import {
   getTemplate,
   loadGlobalInstructions,
   summarizeEnvironment
-} from "../chunk-IVUJDISU.js";
-import "../chunk-LRHOS4ZN.js";
+} from "../chunk-GFTW23FV.js";
+import "../chunk-SPILYYDF.js";
+import "../chunk-I6PKJ7XQ.js";
 export {
   DEFAULT_INSTRUCTION_PATTERNS,
   DEFAULT_MAX_DEPTH,