Agent skills

import os
from launchdarkly_ai_server import init_client
from launchdarkly_ai_server.experimental.skills import FDv2SkillStore, set_skill_store

store = FDv2SkillStore(os.environ["LD_SDK_KEY"]).start()
if not store.wait_for_skills(timeout=10):
    # No payload arrived. Reconciling now would find an empty store.
    log.warning("skill delivery has not answered: %s", store.failed or "still waiting")
set_skill_store(store)
await init_client()
# ... at shutdown:
store.close()

import hashlib
from launchdarkly_ai_server.experimental.skills import InMemorySkillStore, set_skill_store

SKILL_MD = "---\nname: PDF Extraction\n---\nExtract text from PDFs.\n"
store = InMemorySkillStore()
store.put({
    "key": "pdf-extraction",
    "version": 2,
    "content": SKILL_MD,
    "contentHash": hashlib.sha256(SKILL_MD.encode("utf-8")).hexdigest(),
})
set_skill_store(store)

from launchdarkly_ai_server import inspect_config
from launchdarkly_ai_server.experimental.skills import skill_refs

info = await inspect_config("doc-agent", {"kind": "user", "key": "user-123"})
if info["config"] is not None:   # None if the config could not be resolved; skill_refs raises ValueError on it
    refs = skill_refs(info["config"])   # [SkillReference(key='pdf-extraction', version=2)]

skills = []
for r in refs:
    skill_id, provider_version = PROVIDER_SKILLS[(r.key, r.version)]
    skills.append({"type": "custom", "skill_id": skill_id, "version": provider_version})

response = anthropic.beta.messages.create(..., container={"skills": skills})

from launchdarkly_ai_server.experimental.skills import get_skill, get_skills, all_skills, get_skill_result

skill = await get_skill("pdf-extraction")               # newest available, or None
pinned = await get_skill("pdf-extraction", version=2)   # exactly version 2, or None
batch = await get_skills(refs)                          # input order; misses omitted
everything = await all_skills()                         # one per key, newest version
text = skill.content.decode("utf-8") if skill else None

outcome = await get_skill_result("pdf-extraction")
if outcome.reason == "integrity_failure":
    raise SystemExit(f"refusing to start: {outcome.detail}")
elif outcome.reason == "store_unavailable":
    ...  # outage, not revocation: retry or run degraded
elif outcome.reason in ("absent", "wrong_version"):
    ...  # carry on without the skill
else:
    print(outcome.skill.content)

from pathlib import Path
from launchdarkly_ai_server import init_client, inspect_config
from launchdarkly_ai_server.experimental.skills import set_skill_store, skill_refs, write_skills

set_skill_store(store)
await init_client()
info = await inspect_config("doc-agent", context)

Path(".claude").mkdir(exist_ok=True)         # the root's parent must already exist
if info["config"] is None:
    log.error("config unavailable; skipping reconcile")
else:
    report = await write_skills(skill_refs(info["config"]), ".claude/skills")
    for action in report.errors:
        log.error("skill %s: %s", action.key or "<run>", action.error)

run_agent()   # the agent discovers .claude/skills/<key>/SKILL.md

from pathlib import Path
from launchdarkly_ai_server import inspect_config
from launchdarkly_ai_server.experimental.skills import skill_refs, watch_skills

info = await inspect_config("doc-agent", context)
if info["config"] is None:
    log.error("config unavailable; skipping reconcile")
    run_agent()
else:
    Path(".claude").mkdir(exist_ok=True)         # the root's parent must already exist
    report, watcher = await watch_skills(skill_refs(info["config"]), ".claude/skills")
    try:
        run_agent()
    finally:
        watcher.close()

import { initClient } from '@launchdarkly/ai-server';
import { FDv2SkillStore, setSkillStore } from '@launchdarkly/ai-server/experimental';

const store = new FDv2SkillStore(process.env.LD_SDK_KEY!).start();
if (!(await store.waitForSkills({ timeoutSeconds: 10 }))) {
  console.warn(`skill delivery has not answered: ${store.failed ?? 'still waiting'}`);
}
setSkillStore(store);
await initClient();
// ... at shutdown:
await store.close();

import { InMemorySkillStore, setSkillStore } from '@launchdarkly/ai-server/experimental';

const store = new InMemorySkillStore();
store.put({
  key: 'pdf-extraction',
  version: 2,
  content: skillMd,
  contentHash: computedSha256Hex,
});
setSkillStore(store);

import { inspectConfig } from '@launchdarkly/ai-server';
import { skillRefs } from '@launchdarkly/ai-server/experimental';

const info = await inspectConfig('doc-agent', { kind: 'user', key: 'user-123' });
if (info.config) {   // null if the config could not be resolved; skillRefs throws on it
  const refs = skillRefs(info.config);   // [{ key: 'pdf-extraction', version: 2 }]
}

import { getSkill, getSkills, allSkills, getSkillResult } from '@launchdarkly/ai-server/experimental';

const newest = await getSkill('pdf-extraction');
const pinned = await getSkill('pdf-extraction', { version: 2 });
const batch = await getSkills(refs);
const everything = await allSkills();
const text = new TextDecoder().decode(newest?.content);

import { initClient, inspectConfig } from '@launchdarkly/ai-server';
import { setSkillStore, skillRefs, writeSkills } from '@launchdarkly/ai-server/experimental';

setSkillStore(store);
await initClient();
const info = await inspectConfig('doc-agent', context);

if (!info.config) {
  console.error('config unavailable; skipping reconcile');
} else {
  const report = await writeSkills(skillRefs(info.config), '.claude/skills');
  if (!report.ok) {
    for (const action of report.errors) console.error(`skill ${action.key}: ${action.error}`);
  }
}

import { inspectConfig } from '@launchdarkly/ai-server';
import { skillRefs, watchSkills } from '@launchdarkly/ai-server/experimental';

const info = await inspectConfig('doc-agent', context);
if (!info.config) {
  console.error('config unavailable; skipping reconcile');
  // run the agent
} else {
  const { watcher } = await watchSkills(skillRefs(info.config), '.claude/skills');
  try {
    // run the agent
  } finally {
    await watcher.close();
  }
}