Skip to content

Release Notes - v0.11.0

Release Date: 2026-08-02

Overview

This release adds capability-based skill discovery, MCP-to-omniskill bridging, a migration toolkit for bespoke tool layers, reference role implementations, and several MCP server/OAuth2 hardening features. As part of pre-1.0 interface stabilization, both role.Role and skill.Skill gain a Version() method — a breaking change for any implementation that doesn't embed BaseRole/BaseSkill.

Installation

go get github.com/plexusone/omniskill@v0.11.0

Requires Go 1.26+ and MCP Go SDK v1.7.0+.

Highlights

  • MCP bridging - mount remote MCP servers as local skills via the new mcp/bridge package
  • Migration toolkit - migration package with adapters and a completeness checker for moving bespoke tool layers onto omniskill
  • Capability-based discovery - registry.DiscoveryRegistry lets agents find skills by capability or keyword instead of by name
  • Reference roles - roles package ships working CodeReviewer and MeetingPM implementations
  • Interface stabilization - Role and Skill interfaces gain Version() ahead of a future v1.0

What's New

MCP Bridging (mcp/bridge)

Mount a remote MCP server as a local skill so its tools are callable through the standard skill.Tool interface:

import (
    "github.com/plexusone/omniskill/mcp/bridge"
    "github.com/plexusone/omniskill/registry"
)

// Connect to a remote MCP server
c := client.New("my-client", "1.0.0", nil)
session, err := c.ConnectCommand(ctx, exec.Command("npx", "-y", "@modelcontextprotocol/server-github"), nil)

// Bridge it into a local skill
b := bridge.NewBridge(session)
remoteSkill, err := b.ToSkill(ctx)

reg := registry.New()
reg.Register(remoteSkill)

tool, _ := reg.GetTool("github.create_issue")
result, err := tool.Call(ctx, map[string]any{"owner": "myorg", "repo": "myrepo", "title": "Bug report"})

Tool names, descriptions, and JSON Schema input schemas are preserved; calls proxy through the MCP session and errors are wrapped with context.

Migration Toolkit (migration)

Helps PlexusOne projects with custom tool layers move onto omniskill incrementally:

import "github.com/plexusone/omniskill/migration"

// Wrap a legacy tool so it satisfies skill.Tool
adapted := migration.AdaptTool(legacyTool)

s := &skill.BaseSkill{SkillName: "legacy", SkillTools: []skill.Tool{adapted}}
reg.Register(s)

// Check migration completeness
issues := migration.Check(reg)
for _, issue := range issues {
    fmt.Printf("[%s] %s: %s\n", issue.Severity, issue.Location, issue.Message)
}

Workflow: wrap legacy tools with adapters → register in the omniskill registry → run Check() → replace adapters with native implementations → re-run Check() to confirm completion. See docs/migration/README.md for the full guide.

Capability-Based Skill Discovery (registry)

Agents can now query the registry by capability or keyword instead of needing to know a skill's name:

import "github.com/plexusone/omniskill/registry"

type MySkill struct{ skill.BaseSkill }

func (s *MySkill) Capabilities() []registry.Capability {
    return []registry.Capability{registry.CapabilityCodeExecute, registry.CapabilityCodeTest}
}

reg := registry.NewDiscovery()
reg.Register(&MySkill{})

skills := reg.FindByCapability(registry.CapabilityCodeExecute)
skills = reg.FindByAnyCapability([]registry.Capability{registry.CapabilityFileRead, registry.CapabilityFileWrite})
skills = reg.FindByKeyword("test")

Skills opt in via the CapabilityProvider and KeywordProvider interfaces, or capabilities can be registered explicitly with RegisterCapabilities. Standard capability constants cover file, HTTP, code, git, database, communication, and search categories. clawhub.Hub gains matching Discover() and RecommendSkills() methods for marketplace-wide capability search.

Installer Version Pinning (installer)

VersionConstraint and SemVer support common version-range syntax for pinning skill dependencies:

import "github.com/plexusone/omniskill/installer"

c, err := installer.ParseVersionConstraint("^1.2.3") // >=1.2.3, <2.0.0
c, err  = installer.ParseVersionConstraint("~1.2.3") // >=1.2.3, <1.3.0
c, err  = installer.ParseVersionConstraint(">=1.0.0")
c, err  = installer.ParseVersionConstraint("latest")

v, _ := installer.ParseSemVer("1.4.0")
c.Matches(v) // true

Pack Publishing, Validation, and Scaffolding (pack)

Three additions round out the skill-pack authoring workflow:

  • Validation - pack.ValidationResult/ValidationError check a SKILL.md tree for errors and warnings before packaging.
  • Publishing - PublishConfig/PublishBundle produce a checksummed, validated tarball ready to publish:
bundle, err := pack.PrepareForPublish(pack.PublishConfig{
    SkillsDir: "./skills",
    PackName:  "my-pack",
    OutputDir: "./dist",
    Strict:    true,
})
// bundle.BundlePath, bundle.Checksum, bundle.Size
  • Scaffolding - generates a new SkillPack Go source file from a skills directory, optionally embedding the git commit hash as the pack version (ScaffoldConfig.IncludeVersion).

OAuth2 Token Revocation (mcp/oauth2)

Server.RevocationHandler() implements RFC 7009 token revocation, mounted by default at /oauth/revoke. Per the spec, the endpoint always returns 200 OK, whether or not the token was found, to avoid leaking token validity.

MCP Server Middleware (mcp/server)

Two new middleware additions for hardening an MCP HTTP server:

  • Rate limiting - NewRateLimiter implements a per-client token-bucket limiter:
import runtime "github.com/plexusone/omniskill/mcp/server"

rl := runtime.NewRateLimiter(&runtime.RateLimiterConfig{
    RequestsPerSecond: 5,
    BurstSize:         10,
})
handler = rl.Middleware()(handler)
  • Tool authorization - NewToolAuthorizer and NewPolicyAuthorizer gate access to specific tools per client.
  • Structured logging - LoggingMiddleware logs request start (DEBUG) and completion (INFO), including method, path, status, and duration, via slog.

A WebSocket transport evaluation stub was also added under mcp/transport as groundwork for a future transport option.

Reference Role Implementations (roles)

New package with working example roles built on role.BaseRole:

import "github.com/plexusone/omniskill/roles"

reviewer := roles.NewCodeReviewer(roles.CodeReviewerConfig{
    Strictness: roles.StrictnessBalanced,
})
err := reviewer.Init(ctx, skills)

pm := roles.NewMeetingPM()
err = pm.Init(ctx, skills)

CodeReviewer and MeetingPM demonstrate behaviors, policies, workflows, metrics, and delegation, and can be used directly or as templates for custom roles.

Role Skill Validation (role)

ValidateSkills checks a role's declared required/optional skills against an available skill map before calling Init, returning a MissingSkillError with actionable detail:

if err := role.ValidateSkills(myRole, availableSkills); err != nil {
    return err // *role.MissingSkillError
}

Skill Parameter Schema (skill)

skill.Parameter gained additional JSON Schema fields, enabling richer tool input schema declarations without dropping down to raw JSON Schema.

Breaking Changes

role.Role interface adds Version() string

Before (v0.10.0 and earlier):

type Role interface {
    Name() string
    Description() string
    Spec() *RoleSpec
    // ...
}

After (v0.11.0):

type Role interface {
    Name() string
    Description() string
    Version() string // NEW
    Spec() *RoleSpec
    // ...
}

Types embedding role.BaseRole get Version() for free (backed by the new RoleVersion field) and require no changes. Types implementing Role directly must add a Version() string method.

skill.Skill interface adds Version() string

Same pattern as Role: types embedding skill.BaseSkill are unaffected; direct implementers (this release fixed MarkdownSkill and SessionSkill internally) must add the method.

func (s *MySkill) Version() string {
    return "1.0.0" // or "" if unversioned
}

Migration Guide

From v0.10.0

  1. If you implement role.Role or skill.Skill directly (without embedding role.BaseRole/skill.BaseSkill), add a Version() string method. Return "" if the type is unversioned.
  2. To make a skill discoverable by capability, implement registry.CapabilityProvider (and optionally registry.KeywordProvider), or call DiscoveryRegistry.RegisterCapabilities explicitly.
  3. No changes are required for skills or roles that already embed BaseSkill/BaseRole.

Dependencies

  • Bump github.com/modelcontextprotocol/go-sdk from v1.6.1 to v1.7.0
  • Bump golang.org/x/mod from v0.37.0 to v0.38.0

Contributors

  • John Wang
  • Claude Opus 4.5