@cuylabs/agent-core 0.3.0 → 0.5.0

package/README.md

@@ -1,19 +1,26 @@
 # @cuylabs/agent-core
 
-Embeddable AI agent infrastructure using Vercel AI SDK. Core building blocks for streaming AI agents with session management, resilience, and model capabilities.
+Embeddable AI agent infrastructure using Vercel AI SDK. Core building blocks for AI agents with session management, tools, skills, sub-agents, and tracing.
 
 ## Features
 
-- **Agent Framework** - Create AI agents with tool support and streaming responses
-- **Session Management** - Persistent conversation state with branching support
-- **LLM Streaming** - Real-time streaming with proper backpressure handling
-- **Error Resilience** - Automatic retry with exponential backoff
-- **Context Management** - Token counting and automatic context pruning
-- **Tool Framework** - Type-safe tool definitions with Zod schemas
-- **Approval System** - Configurable tool approval workflows
-- **Checkpoint System** - Undo/restore capabilities for file operations
-- **Model Capabilities** - Runtime model capability detection
-- **MCP Support** - Extend agents with Model Context Protocol servers
+- **Named Agents** — `name` field for identity in spans, runtime traces, and logging
+- **Agent Framework** — Create AI agents with tool support and streaming responses
+- **OpenTelemetry Tracing** — Built-in tracing with a single `tracing` config — Zipkin, Phoenix, any OTLP backend
+- **Session Management** — Persistent conversation state with branching support
+- **Execution Streaming** — Real-time event streaming with proper backpressure handling
+- **Error Resilience** — Automatic retry with exponential backoff
+- **Context Management** — Token counting and automatic context pruning
+- **Tool Framework** — Type-safe tool definitions with Zod schemas
+- **Middleware** — Composable lifecycle hooks for tool interception, prompt injection, logging, and guardrails
+- **Skills** — Modular knowledge packs with progressive disclosure (L1 summary → L2 content → L3 resources)
+- **Approval System** — Configurable tool approval via middleware (rules + interactive prompts)
+- **Checkpoint System** — Undo/restore capabilities for file operations
+- **Model Capabilities** — Runtime model capability detection
+- **MCP Support** — Extend agents with Model Context Protocol servers
+- **Sub-Agents** — Fork agents with inherited config, run tasks in parallel, or let the LLM delegate via `invoke_agent`
+- **Presets** — Reusable agent configurations with tool filtering
+- **Runtime Integration** — Extracted turn-runner phases for durable workflow integration
 
 ## Installation
 
@@ -38,28 +45,47 @@ npm install @ai-sdk/openai-compatible
 
 ## Quick Start
 
+Everything is available from the root import, plus focused subpath imports for clearer boundaries:
+
+```typescript
+import { createAgent, Tool } from "@cuylabs/agent-core";            // full API
+import { defineTool } from "@cuylabs/agent-core/tool";              // tools only
+import { createSkillRegistry } from "@cuylabs/agent-core/skill";    // skill system
+import { createSubAgentTools } from "@cuylabs/agent-core/sub-agent"; // sub-agents
+import { createAgentTaskRunner } from "@cuylabs/agent-core/runtime"; // runtime
+import type { AgentMiddleware } from "@cuylabs/agent-core/middleware"; // middleware
+import { createPromptBuilder } from "@cuylabs/agent-core/prompt";    // prompts
+import { createMCPManager } from "@cuylabs/agent-core/mcp";          // MCP integration
+```
+
+Additional focused entrypoints are available for `storage`, `context`, `reasoning`,
+`capabilities`, `models`, and `tracking` when you want imports to mirror the
+module layout.
+
 ```typescript
 import { createAgent, Tool } from "@cuylabs/agent-core";
 import { openai } from "@ai-sdk/openai";
 import { z } from "zod";
 
 // Define tools
-const tools: Tool[] = [
-  {
-    name: "greet",
-    description: "Greet a user by name",
-    parameters: z.object({
-      name: z.string().describe("Name to greet"),
-    }),
-    execute: async ({ name }) => `Hello, ${name}!`,
-  },
-];
+const greet = Tool.define("greet", {
+  description: "Greet a user by name",
+  parameters: z.object({
+    name: z.string().describe("Name to greet"),
+  }),
+  execute: async ({ name }) => ({
+    title: "Greeting",
+    output: `Hello, ${name}!`,
+    metadata: {},
+  }),
+});
 
 // Create agent
 const agent = createAgent({
+  name: "my-assistant",
   model: openai("gpt-4o"),
-  cwd: process.cwd(),
-  tools,
+  tools: [greet],
+  systemPrompt: "You are a helpful assistant.",
 });
 
 // Stream responses
@@ -68,7 +94,7 @@ for await (const event of agent.chat("session-1", "Hello!")) {
     case "text-delta":
       process.stdout.write(event.text);
       break;
-    case "tool-call":
+    case "tool-start":
       console.log(`Calling tool: ${event.toolName}`);
       break;
     case "tool-result":
@@ -86,9 +112,9 @@ for await (const event of agent.chat("session-1", "Hello!")) {
 ### Local Models (Ollama Example)
 
 ```typescript
-import { createAgent, createModelResolver } from "@cuylabs/agent-core";
+import { createAgent, createResolver } from "@cuylabs/agent-core";
 
-const resolveModel = createModelResolver({
+const resolveModel = createResolver({
   engines: {
     ollama: {
       adapter: "openai-compatible",
@@ -140,36 +166,170 @@ const memoryStorage = new MemoryStorage();
 
 // File-based persistent storage
 const fileStorage = new FileStorage({
-  dataDir: "/path/to/data",
+  directory: "/path/to/data",
 });
 
 const sessions = new SessionManager(fileStorage);
-await sessions.createSession({ id: "my-session" });
+await sessions.create({ id: "my-session", cwd: process.cwd() });
 ```
 
 ### Tool Framework
 
 ```typescript
-import { defineTool, Tool, ToolRegistry } from "@cuylabs/agent-core";
+import { Tool } from "@cuylabs/agent-core";
 import { z } from "zod";
 
-const myTool = defineTool({
-  name: "calculate",
-  description: "Perform a calculation",
+const calculator = Tool.define("calculator", {
+  description: "Evaluate a math expression",
   parameters: z.object({
     expression: z.string(),
   }),
   execute: async ({ expression }, ctx) => {
-    // ctx provides sessionId, cwd, abort signal, etc.
-    return eval(expression); // Don't actually do this!
+    // ctx provides sessionID, cwd, abort signal, host, etc.
+    return {
+      title: "Calculator",
+      output: String(eval(expression)), // Don't actually do this!
+      metadata: {},
+    };
+  },
+});
+```
+
+### Middleware
+
+Composable lifecycle hooks for tool interception, prompt injection, logging, and guardrails:
+
+```typescript
+import { createAgent, type AgentMiddleware, approvalMiddleware } from "@cuylabs/agent-core";
+
+// Simple logging middleware
+const logger: AgentMiddleware = {
+  name: "logger",
+  async beforeToolCall(tool, args) {
+    console.log(`→ ${tool}`, args);
+    return { action: "allow" };
+  },
+  async afterToolCall(tool, _args, result) {
+    console.log(`← ${tool}`, result.title);
+    return result;
+  },
+  async onChatStart(sessionId, message) {
+    console.log(`Chat started: ${sessionId}`);
+  },
+  async onChatEnd(sessionId, { usage, error }) {
+    console.log(`Chat ended: ${usage?.totalTokens} tokens`);
+  },
+};
+
+// Guardrail middleware — block dangerous tools
+const guardrail: AgentMiddleware = {
+  name: "guardrail",
+  async beforeToolCall(tool) {
+    if (tool === "bash") {
+      return { action: "deny", reason: "Shell commands are disabled." };
+    }
+    return { action: "allow" };
+  },
+};
+
+const agent = createAgent({
+  model: openai("gpt-4o"),
+  tools: myTools,
+  middleware: [
+    logger,
+    guardrail,
+    approvalMiddleware({
+      rules: [{ pattern: "*", tool: "read_file", action: "allow" }],
+      onRequest: async (req) => {
+        // Prompt user for approval
+        return await askUser(req);
+      },
+    }),
+  ],
+});
+```
+
+Middleware hooks: `beforeToolCall`, `afterToolCall`, `promptSections`, `onEvent`, `onChatStart`, `onChatEnd`. Sub-agents inherit middleware via `fork()`.
+
+### Tracing (OpenTelemetry)
+
+Enable full tracing with a single `tracing` field — no manual provider setup:
+
+```typescript
+import { createAgent } from "@cuylabs/agent-core";
+import { openai } from "@ai-sdk/openai";
+import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-node";
+import { ZipkinExporter } from "@opentelemetry/exporter-zipkin";
+
+const agent = createAgent({
+  name: "my-agent",
+  model: openai("gpt-4o"),
+  tools: [myTool],
+  tracing: {
+    spanProcessor: new SimpleSpanProcessor(
+      new ZipkinExporter({ url: "http://localhost:9411/api/v2/spans" }),
+    ),
   },
 });
 
-// Register tools
-const registry = new ToolRegistry();
-registry.register(myTool);
+// ... use agent ...
+
+// Flush spans before exit
+await agent.close();
+```
+
+This auto-creates agent-level, tool-level, and AI SDK LLM spans following the [GenAI Semantic Conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/). Works with Zipkin, Arize Phoenix, Jaeger, or any OTLP backend. See [docs/tracing.md](docs/tracing.md) for the full reference.
+
+### Skills
+
+Modular knowledge packs with three-level progressive disclosure:
+
+```typescript
+import { createAgent, createSkillRegistry, createSkillTools } from "@cuylabs/agent-core";
+
+// Discover skills from SKILL.md files
+const registry = await createSkillRegistry(process.cwd(), {
+  externalDirs: [".agents", ".claude"],
+});
+
+// Create skill tools (skill + skill_resource)
+const skillTools = createSkillTools(registry);
+
+// Inject L1 summary into system prompt, give agent skill tools
+const agent = createAgent({
+  model: openai("gpt-4o"),
+  tools: [...myTools, ...skillTools],
+  systemPrompt: `You are a coding assistant.\n\n${registry.formatSummary()}`,
+});
+```
+
+Skills use the `SKILL.md` format with YAML frontmatter. See [examples/skills/](examples/skills/) for samples.
+
+### Built-in Sub-Agent Tools
+
+Let the LLM delegate work to specialized sub-agents via tool calls:
+
+```typescript
+import { createAgent, createSubAgentTools, Presets } from "@cuylabs/agent-core";
+import type { AgentProfile } from "@cuylabs/agent-core";
+
+const profiles: AgentProfile[] = [
+  { name: "explorer", description: "Fast code search", preset: Presets.explore },
+  { name: "reviewer", description: "Thorough code review", preset: Presets.review },
+];
+
+const parent = createAgent({ model, tools: codeTools });
+const subTools = createSubAgentTools(parent, { profiles, async: true });
+
+const agent = createAgent({
+  model,
+  tools: [...codeTools, ...subTools],
+});
+// The LLM can now call invoke_agent, wait_agent, and close_agent
 ```
 
+Tools: `invoke_agent` (spawn), `wait_agent` (collect results), `close_agent` (cancel). Supports sync and async modes, depth limiting, and concurrency control. See [docs/subagents.md](docs/subagents.md#built-in-sub-agent-tools-llm-callable).
+
 ### Error Handling & Retry
 
 ```typescript
@@ -262,14 +422,29 @@ The `chat()` method yields these event types:
 | Event Type | Description |
 |------------|-------------|
 | `text-delta` | Streaming text chunk |
-| `tool-call` | Tool invocation started |
+| `text-start` / `text-end` | Text generation boundaries |
+| `tool-start` | Tool invocation started |
 | `tool-result` | Tool execution completed |
-| `reasoning` | Model reasoning (if supported) |
-| `message` | Complete assistant message |
+| `tool-error` | Tool execution failed |
+| `step-start` / `step-finish` | LLM step boundaries with usage stats |
+| `reasoning-delta` | Model reasoning chunk (if supported) |
+| `status` | Agent state changes (thinking, calling-tool, etc.) |
+| `doom-loop` | Repeated tool call pattern detected |
+| `context-overflow` | Context window exceeded |
+| `message` | Complete user/assistant message |
 | `complete` | Stream finished with usage stats |
-| `error` | Error occurred |
+| `error` | Unrecoverable error |
+
+See [examples/03-streaming.ts](examples/03-streaming.ts) for a complete event handling example.
 
 ## Concurrency Note
 
 When using `runConcurrent()` to run multiple tasks in parallel, be aware that all tasks share the same `SessionManager` instance. For independent conversations, create separate `Agent` instances or use distinct session IDs.
 
+## Examples
+
+See [examples/](examples/) for 20 runnable examples covering every feature — from basic chat to middleware, skills, tracing, and Docker execution. The [examples README](examples/README.md) has setup instructions and run commands.
+
+## Documentation
+
+See [docs/](docs/) for in-depth guides on each subsystem.

package/dist/builder-RcTZuYnO.d.ts

@@ -0,0 +1,34 @@
+import { P as PromptConfig, a as PromptBuildContext, M as MiddlewareRunner, b as PromptSection, c as ModelFamily } from './runner-C7aMP_x3.js';
+import { S as SkillRegistry } from './registry-CuRWWtcT.js';
+
+interface PromptSectionPreview {
+    id: string;
+    label: string;
+    priority: number;
+    size: number;
+}
+
+declare class PromptBuilder {
+    private readonly config;
+    private customSections;
+    private envCache?;
+    private instructionCache?;
+    private skillRegistryCache?;
+    constructor(config?: PromptConfig);
+    build(context: PromptBuildContext, middleware?: MiddlewareRunner): Promise<string>;
+    addSection(section: PromptSection): void;
+    removeSection(id: string): boolean;
+    toggleSection(id: string, enabled: boolean): void;
+    getSections(): PromptSection[];
+    hasSection(id: string): boolean;
+    clearCache(): void;
+    getSkillRegistry(cwd: string): Promise<SkillRegistry>;
+    getModelFamily(model: PromptBuildContext["model"]): ModelFamily;
+    getBaseTemplate(model: PromptBuildContext["model"]): string;
+    preview(context: PromptBuildContext, middleware?: MiddlewareRunner): Promise<PromptSectionPreview[]>;
+    private getEnvironment;
+    private getInstructions;
+}
+declare function createPromptBuilder(config?: PromptConfig): PromptBuilder;
+
+export { PromptBuilder as P, createPromptBuilder as c };

package/dist/capabilities/index.d.ts

@@ -0,0 +1,97 @@
+import { C as CapabilitySource, S as SourcePriority, b as SourceResult, P as ProviderCompatibility, R as ResolverOptions, M as ModelEntry, c as ModelCapabilities } from '../resolver-DOfZ-xuk.js';
+export { D as DEFAULT_RESOLVER_OPTIONS, I as InputModality, d as ModelCapabilityResolver, N as NetworkStatus, O as OutputModality, f as ResolutionResult, g as configureResolver, e as extractModelId, a as extractProvider, h as getDefaultResolver } from '../resolver-DOfZ-xuk.js';
+export { g as getModelId, a as getProviderId } from '../identifiers-BLUxFqV_.js';
+export { g as getNetworkStatus } from '../network-D76DS5ot.js';
+import 'ai';
+
+/**
+ * Pattern-Based Capability Detection for @cuylabs/agent-core
+ *
+ * Static pattern matching for model capabilities when no external data is available.
+ * This is the fallback layer - always works offline.
+ */
+
+/**
+ * Infer provider from model ID
+ */
+declare function inferProvider(modelId: string): string | undefined;
+/**
+ * Pattern-based capability source
+ * Always available, uses heuristics to detect capabilities
+ */
+declare class PatternCapabilitySource implements CapabilitySource {
+    readonly priority = SourcePriority.PatternMatch;
+    readonly name = "Pattern Matching";
+    lookup(modelId: string, providerHint?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * Quick check if a model ID likely supports reasoning
+ */
+declare function likelySupportsReasoning(modelId: string): boolean;
+/**
+ * Get provider compatibility for a model
+ */
+declare function getProviderCompatibility(modelId: string, provider?: string): ProviderCompatibility | undefined;
+
+type CapabilityOverrides = ResolverOptions["modelOverrides"];
+type OverrideLookup = {
+    override?: Partial<ModelCapabilities>;
+    matchedKey?: string;
+};
+declare function findCapabilityOverride(overrides: CapabilityOverrides, modelId: string, provider?: string): OverrideLookup;
+declare function applyCapabilityOverride(entry: ModelEntry, override?: Partial<ModelCapabilities>): ModelEntry;
+
+declare class CapabilityCache {
+    private adapter;
+    private memoryCache;
+    private ttlMs;
+    private loaded;
+    constructor(options?: Partial<ResolverOptions>);
+    private load;
+    get(modelId: string, provider?: string): Promise<ModelEntry | undefined>;
+    set(entry: ModelEntry): Promise<void>;
+    setMany(entries: ModelEntry[]): Promise<void>;
+    persist(): Promise<void>;
+    clear(): Promise<void>;
+    stats(): {
+        size: number;
+        loaded: boolean;
+    };
+    getAll(): Promise<ModelEntry[]>;
+    getAllByProvider(): Promise<Record<string, ModelEntry[]>>;
+}
+declare class CacheCapabilitySource implements CapabilitySource {
+    private cache;
+    readonly priority = SourcePriority.LocalCache;
+    readonly name = "Local Cache";
+    constructor(cache: CapabilityCache);
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+}
+
+declare class RemoteCapabilityFetcher {
+    private apiUrl;
+    private timeoutMs;
+    private cache;
+    private lastFetchTime;
+    private minFetchInterval;
+    constructor(cache: CapabilityCache, options?: Partial<ResolverOptions>);
+    fetchAll(): Promise<ModelEntry[]>;
+    ping(): Promise<boolean>;
+}
+
+declare class RemoteCapabilitySource implements CapabilitySource {
+    readonly priority = SourcePriority.RemoteAPI;
+    readonly name = "Remote API (models.dev)";
+    private fetcher;
+    private cache;
+    private fetchPromise;
+    private enabled;
+    constructor(cache: CapabilityCache, options?: Partial<ResolverOptions>);
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+    refresh(): Promise<void>;
+}
+
+export { CacheCapabilitySource, CapabilityCache, type CapabilityOverrides, CapabilitySource, ModelCapabilities, ModelEntry, PatternCapabilitySource, ProviderCompatibility, RemoteCapabilityFetcher, RemoteCapabilitySource, ResolverOptions, SourcePriority, SourceResult, applyCapabilityOverride, findCapabilityOverride, getProviderCompatibility, inferProvider, likelySupportsReasoning };

package/dist/capabilities/index.js

@@ -0,0 +1,46 @@
+import {
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
+  ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
+  configureResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
+  getDefaultResolver,
+  getNetworkStatus,
+  getProviderCompatibility,
+  inferProvider,
+  likelySupportsReasoning
+} from "../chunk-QWFMX226.js";
+import {
+  getModelId,
+  getProviderId
+} from "../chunk-DWYX7ASF.js";
+export {
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
+  ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
+  configureResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
+  getDefaultResolver,
+  getModelId,
+  getNetworkStatus,
+  getProviderCompatibility,
+  getProviderId,
+  inferProvider,
+  likelySupportsReasoning
+};

package/dist/chunk-6TDTQJ4P.js

@@ -0,0 +1,116 @@
+// src/models/resolver.ts
+function parseKey(input) {
+  const [engineId, ...rest] = input.split("/");
+  if (!engineId || rest.length === 0) return null;
+  return { engineId, modelId: rest.join("/") };
+}
+function mergeSettings(base, override) {
+  return {
+    apiKey: override?.apiKey ?? base?.apiKey,
+    baseUrl: override?.baseUrl ?? base?.baseUrl,
+    headers: {
+      ...base?.headers ?? {},
+      ...override?.headers ?? {}
+    },
+    extra: {
+      ...base?.extra ?? {},
+      ...override?.extra ?? {}
+    }
+  };
+}
+function settingsKey(settings, adapter, engineId) {
+  return JSON.stringify({
+    engineId,
+    adapter,
+    apiKey: settings.apiKey ?? "",
+    baseUrl: settings.baseUrl ?? "",
+    headers: settings.headers ?? {},
+    extra: settings.extra ?? {}
+  });
+}
+function buildOptions(settings) {
+  const opts = { ...settings.extra ?? {} };
+  if (settings.apiKey) opts.apiKey = settings.apiKey;
+  if (settings.baseUrl) opts.baseURL = settings.baseUrl;
+  if (settings.headers && Object.keys(settings.headers).length > 0) opts.headers = settings.headers;
+  return opts;
+}
+async function createFactory(adapter, settings) {
+  const asModel = (m) => m;
+  const opts = buildOptions(settings);
+  switch (adapter) {
+    case "openai": {
+      const { createOpenAI } = await import("@ai-sdk/openai").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/openai" is required for the "openai" adapter. Install it with: pnpm add @ai-sdk/openai`
+        );
+      });
+      const provider = createOpenAI(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "anthropic": {
+      const { createAnthropic } = await import("@ai-sdk/anthropic").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/anthropic" is required for the "anthropic" adapter. Install it with: pnpm add @ai-sdk/anthropic`
+        );
+      });
+      const provider = createAnthropic(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "google": {
+      const { createGoogleGenerativeAI } = await import("@ai-sdk/google").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/google" is required for the "google" adapter. Install it with: pnpm add @ai-sdk/google`
+        );
+      });
+      const provider = createGoogleGenerativeAI(opts);
+      return (modelId) => asModel(provider.languageModel(modelId));
+    }
+    case "openai-compatible": {
+      const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/openai-compatible" is required for the "openai-compatible" adapter. Install it with: pnpm add @ai-sdk/openai-compatible`
+        );
+      });
+      const provider = createOpenAICompatible({
+        name: opts.name ?? "custom",
+        baseURL: opts.baseURL ?? "",
+        ...opts.apiKey ? { apiKey: opts.apiKey } : {},
+        ...opts.headers ? { headers: opts.headers } : {}
+      });
+      return (modelId) => provider.languageModel(modelId);
+    }
+    default:
+      throw new Error(`No factory registered for adapter: ${adapter}`);
+  }
+}
+function createResolver(directory) {
+  const factoryCache = /* @__PURE__ */ new Map();
+  return async (key) => {
+    const parsed = parseKey(key);
+    const entry = parsed ? void 0 : directory.entries?.[key];
+    const engineId = parsed?.engineId ?? entry?.engine;
+    const modelId = parsed?.modelId ?? entry?.id;
+    if (!engineId || !modelId) {
+      throw new Error(`Unknown model reference: ${key}`);
+    }
+    const engine = directory.engines[engineId];
+    if (!engine) {
+      throw new Error(`Unknown engine: ${engineId}`);
+    }
+    const settings = mergeSettings(engine.settings, entry?.settings);
+    if (engine.build) {
+      return engine.build(modelId, settings);
+    }
+    const cacheKey = settingsKey(settings, engine.adapter, engineId);
+    const cached = factoryCache.get(cacheKey);
+    if (cached) return cached(modelId);
+    const factory = await createFactory(engine.adapter, settings);
+    factoryCache.set(cacheKey, factory);
+    return factory(modelId);
+  };
+}
+
+export {
+  createResolver
+};