技能与插件

 * Base node class that all nodes must extend.
 * Provides core functionality and type safety.
 */
export abstract class BaseNode<TConfig = unknown> {
  /** Unique identifier for the node */
  readonly id: string;

  /** Unique type identifier for the node */
  abstract readonly type: string;

  /** Node configuration (immutable after construction) */
  protected config: TConfig;

        return decorator

    def skill(
        self,
        tags: Optional[List[str]] = None,
        path: Optional[str] = None,
        name: Optional[str] = None,
        *,
        vc_enabled: Optional[bool] = None,
        require_realtime_validation: bool = False,
    ):
        """

    return ReflectStep(reflector)


def learning_tail(
    reflector: ReflectorLike,
    skill_manager: SkillManagerLike,
    skillbook: Skillbook,
    *,
    dedup_manager: DeduplicationManagerLike | None = None,
    dedup_interval: int = 10,
    checkpoint_dir: str | Path | None = None,
    checkpoint_interval: int = 10,
) -> list[StepProtocol[ACEStepContext]]:

    """The last updated time of the skill."""


class SkillLoaderBase(ABC):
    """The base class for skill loader."""

    @abstractmethod
    async def list_skills(self) -> list[Skill]:
        """List all the skills that can be loaded by this loader."""
        raise NotImplementedError

        }
    }

    pub fn new_mcp(tool: MCPTool) -> Self {
        Self {
            inner: ToolInner::MCP(tool),
        }
    }

    pub fn new_knowledge(tool: KnowledgeTool) -> Self {
        Self {
            inner: ToolInner::Knowledge(tool),
        }

            limits=httpx.Limits(max_connections=100, max_keepalive_connections=20),
        )

    async def build_plugins(
        self,
        tool_ids: list,
        mcp_server_ids: list,
        mcp_server_urls: list,
        workflow_ids: list,
        skills: list | None = None,
    ) -> list[Union[LinkPlugin, McpPlugin, WorkflowPlugin, SkillPlugin]]:

        with self.span.start("BuildPlugins") as sp:

  export type JSON = {
    name: string
    description?: string
    properties?: ObjectProperty[]
    tools?: Tool.JSON[]
    metadata?: Record<string, unknown>
  }
}

/**
 * ObjectInstance creates stateful, namespace-scoped objects for LLMz agents.
 *
 * Objects combine properties (stateful variables) and tools (functions) into a

SDKs: **Go** (stable) | [**Python**](https://github.com/cordum-io/cap) | [**Node**](https://github.com/cordum-io/cap)

## Integration Packs

Extend Cordum with [30+ integration packs](https://github.com/cordum-io/cordum-packs) for Slack, GitHub, AWS, Jira, Terraform, Datadog, PagerDuty, and more. Each pack is a CAP-native worker with policy-gated workflows.

| Pack | Category | Description |
|------|----------|-------------|
| Slack | Communication | Approval notifications and agent alerts |
| GitHub | DevOps | Govern agent actions on repositories |
| AWS | Cloud | Policy-gated cloud operations |
| Kubernetes | DevOps | Governed incident remediation |

_cache_ttl = 300  # 5 minutes


class MCPClient:
    """MCP client with session management.

    This client manages connections to MCP servers and provides a high-level
    interface for interacting with MCP tools, prompts, and resources.

    Example:
        ```python
        transport = StdioTransport(command="python", args=["server.py"])
        client = MCPClient(transport)

const SKILL_KNOWLEDGE_DATA_WAREHOUSE_SERVER_NAME =
  "skill_knowledge_data_warehouse";

export async function getSkillServers(
  auth: Authenticator,
  {
    agentConfiguration,
    skills,
  }: {
    agentConfiguration: LightAgentConfigurationType;
    skills: (SkillResource & { extendedSkill?: SkillResource | null })[];
  }
): Promise<MCPServerConfigurationType[]> {

#!/usr/bin/env python3
"""
Skills Tool Module

This module provides tools for listing and viewing skill documents.
Skills are organized as directories containing a SKILL.md file (the main instructions)
and optional supporting files like references, templates, and examples.

Inspired by Anthropic's Claude Skills system with progressive disclosure architecture:
- Metadata (name ≤64 chars, description ≤1024 chars) - shown in skills_list

"""Unified skill lifecycle manager.

``SkillsManager`` is the single facade that owns skill discovery, loading,
and prompt renderation.  The runtime creates one at startup and downstream
layers read the cached prompt strings.

Typical usage — **config-driven** (runner passes configuration)::

    config = SkillsManagerConfig(
        skills_config=SkillsConfig.from_agent_vars(...),

from lagent.schema import AgentMessage


class Hook:

    def before_agent(
        self,
        agent,
        message: Tuple[AgentMessage],
        session_id: int,
    ):
        pass

        os.environ["CLAUDE_CODE_MAX_OUTPUT_TOKENS"] = str(max_output_tokens)


class ClaudeCodeAgent(AgentBase):
    """
    Wraps the Claude Agent SDK as a generic Agent node in LoongFlow.

    This agent provides Claude with full terminal/file system permissions.
    Claude SDK internally handles Planning -> Execution (Coding/Bash) -> Solving.

    Supports both built-in tools and custom user-defined tools.

    Usage:

  }

  /**
   * Gets the skills processors to add to input processors when workspace has skills.
   * @internal
   */
  private async getSkillsProcessors(
    configuredProcessors: InputProcessorOrWorkflow[],
    requestContext?: RequestContext,
  ): Promise<InputProcessorOrWorkflow[]> {
    // Check if workspace has skills configured
    const workspace = await this.getWorkspace({ requestContext: requestContext || new RequestContext() });
    if (!workspace?.skills) {

)


class SkillsLoader:
    """
    Loader for agent skills.

    Skills are markdown files (SKILL.md) that teach the agent how to use
    specific tools or perform certain tasks.
    """

    def __init__(self, workspace: Path, builtin_skills_dir: Path | None = None, disabled_skills: set[str] | None = None):
        self.workspace = workspace

 * Traverses directories recursively, loads `SKILL.md` files, loads direct root `.md` files as skills, honors ignore files,
 * and returns diagnostics for invalid skill files. Missing input directories are skipped.
 */
export async function loadSkills(
  env: ExecutionEnv,
  dirs: string | string[],
): Promise<{ skills: Skill[]; diagnostics: SkillDiagnostic[] }> {
  const skills: Skill[] = [];
  const diagnostics: SkillDiagnostic[] = [];
  for (const dir of Array.isArray(dirs) ? dirs : [dirs]) {
    const rootInfoResult = await env.fileInfo(dir);
    if (!rootInfoResult.ok) {
      if (rootInfoResult.error.code !== "not_found") {

	// resolve it once via d.DaemonAPI() and thread the shared value
	// everywhere — keeps the type assertion in one place.
	dapi := d.DaemonAPI()
	rt := runtime.New(dapi)

	ta := trustedagents.NewService()
	if err := rt.Register(ta); err != nil {
		log.Fatalf("register trustedagents: %v", err)
	}
	d.RegisterTrustChecker(ta)

	if err := rt.Register(skillinject.NewService(skillinject.Config{})); err != nil {
		log.Fatalf("register skillinject: %v", err)

        """Get names of all loaded skills."""
        return list(self._skills.keys())

    def discover(
        self,
        skill_dirs: Optional[List[str]] = None,
        include_defaults: bool = True,
    ) -> int:
        """Discover skills from directories.

        Args:
            skill_dirs: List of directory paths to scan
            include_defaults: Whether to include default skill directories

    /// </remarks>
    [RequiresUnreferencedCode("Uses reflection to handle various aspects of the function creation and invocation, making it incompatible with AOT scenarios.")]
    [RequiresDynamicCode("Uses reflection to handle various aspects of the function creation and invocation, making it incompatible with AOT scenarios.")]
    public static KernelPlugin AddFromType<T>(this ICollection<KernelPlugin> plugins, string? pluginName = null, IServiceProvider? serviceProvider = null)
    {
        Verify.NotNull(plugins);

        KernelPlugin plugin = KernelPluginFactory.CreateFromType<T>(pluginName, serviceProvider);
        plugins.Add(plugin);
        return plugin;
    }

    /// <summary>Creates a plugin that wraps a new instance of the specified type <typeparamref name="T"/> and adds it into the plugin collection.</summary>

    return [sources]


class AgentSkills(Plugin):
    """Plugin that integrates Agent Skills into a Strands agent.

    The AgentSkills plugin extends the Plugin base class and provides:

    1. A ``skills`` tool that allows the agent to activate skills on demand
    2. System prompt injection of available skill metadata before each invocation
    3. Session persistence of active skill state via ``agent.state``

    Skills can be provided as filesystem paths (to individual skill directories or

import crypto from 'node:crypto'

import { HumanMessage } from '@langchain/core/messages'

import { genId } from '@/lib/id'
import type {
  LearnedSkill,
  LearnedSkillLifecycle,
  LearnedSkillRiskLevel,
  MessageToolEvent,