@tangle-network/agent-app 0.18.0 → 0.19.0

package/dist/skills/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/skills/index.ts"],"sourcesContent":["/**\n * Unified skill + corpus mounter for agent products.\n *\n * Every agent product hand-rolls the same two file-mount systems and then\n * drifts on the seams between them. (1) An ALWAYS-MOUNTED markdown corpus —\n * (`skills/<slug>/SKILL.md`, `doctrine` and `knowledge` markdown trees) — discovered\n * by a Vite `?raw` glob in the Worker bundle and by Node `fs` under the eval\n * CLI, then projected into `resources.files`. (2) A TIER-GATED installable\n * registry — a hand-authored array of `SkillEntry` whose free tier mounts at\n * the harness skill-discovery path and whose paid tier is installed on demand.\n * Both ride the same `resources.files` channel but use different provenance\n * (file-backed vs inline), different mount paths (relative corpus path vs\n * `~/.claude/skills/<id>/SKILL.md`), and different selection rules. This module\n * makes both DATA: a corpus loader that accepts a Vite glob-result map (or an\n * fs fallback), a registry adapter that tier-gates, and a single\n * `composeShellResources` that projects either onto the SDK file-mount shape.\n *\n * Substrate-free over storage, exact over the SDK boundary: the only inbound\n * seam is the glob-result map the consumer passes in (its call site keeps the\n * literal `import.meta.glob` Vite must static-analyze); the only outbound seam\n * is `@tangle-network/sandbox`'s `AgentProfileFileMount[]`, the exact shape the\n * agent profile's `resources.files` consumes. Node builtins are resolved lazily\n * via `process.getBuiltinModule` so a static `node:*` import never reaches the\n * Vite SSR bundle.\n */\n\nimport type { AgentProfileFileMount, AgentProfileResourceRef } from '@tangle-network/sandbox'\n\n/** Construct the inline arm of the SDK's `AgentProfileResourceRef`. Inlined here\n *  so this leaf subpath stays type-only over `@tangle-network/sandbox` — it\n *  carries no runtime dependency on the SDK, just its file-mount type contract. */\nfunction inlineResource(name: string, content: string): AgentProfileResourceRef {\n  return { kind: 'inline', name, content }\n}\n\n/** A Vite eager `?raw` glob result: glob key -> raw file body. The consumer\n *  produces this by calling `import.meta.glob('<lit>', { eager: true, query:\n *  '?raw', import: 'default' })` at its own call site — the literal must stay\n *  literal so Vite can static-analyze it; passing the result here keeps that\n *  constraint at the edge and the loader substrate-free. */\nexport type GlobModules = Record<string, string>\n\n/** One markdown document discovered from the corpus. */\nexport interface CorpusEntry {\n  /** Slug derived from the glob key (folder slug for `SKILL.md` layouts, or the\n   *  normalized relative path for flat `*.md` layouts). */\n  id: string\n  /** Glob/fs key the entry was loaded from, normalized to a stable relative\n   *  form (leading `./` and absolute prefixes stripped). */\n  key: string\n  /** Raw markdown body (including any frontmatter). */\n  content: string\n}\n\n/** A hand-authored, tier-gated installable skill. Mirrors the per-product\n *  registry entry (gtm/insurance `SkillEntry`); the runtime's certified `skill`\n *  artifact kind is unrelated. `skillMd` is the inline body — file provenance\n *  does not apply to the registry. */\nexport interface SkillEntry {\n  id: string\n  name: string\n  description: string\n  author?: { name: string; url?: string }\n  source?: string\n  category?: string\n  tags?: string[]\n  /** Gate keyword. `composeShellResources`/`registrySkills` treat `free` as\n   *  always-mounted; everything else is install-on-demand. */\n  tier: string\n  skillMd: string\n}\n\n/** Harness skill-discovery path the Claude Code / OpenCode backend reads\n *  natively. The registry mounts here; the corpus mounts at its relative path. */\nexport function skillMountPath(id: string): string {\n  return `~/.claude/skills/${id}/SKILL.md`\n}\n\n/** Strip a glob/fs key down to a stable relative form: drop a leading `./`,\n *  and for an absolute fs path keep only the tail from the last anchor segment\n *  the pattern implies. We normalize on the trailing `<dir>/.../*.md` so the\n *  Vite key (`./skills/x/SKILL.md`) and the fs key (`/abs/.../skills/x/SKILL.md`)\n *  collapse to the same value. */\nfunction normalizeKey(key: string, anchor: string): string {\n  const marker = `${anchor}/`\n  const at = key.lastIndexOf(marker)\n  if (at >= 0) return key.slice(at)\n  return key.startsWith('./') ? key.slice(2) : key\n}\n\n/** Folder-slug for a `<anchor>/<slug>/SKILL.md` layout; falls back to the\n *  normalized key (sans `<anchor>/` prefix, sans `.md`) for flat layouts. */\nfunction toCorpusId(normalizedKey: string, anchor: string): string {\n  const nested = normalizedKey.match(new RegExp(`${anchor}/([^/]+)/SKILL\\\\.md$`))\n  if (nested) return nested[1]!\n  const flat = normalizedKey.match(new RegExp(`${anchor}/(.+)\\\\.md$`))\n  if (flat) return flat[1]!\n  return normalizedKey\n}\n\n/** Resolve Node builtins lazily. `process.getBuiltinModule` (Node 22+) is\n *  absent in workerd, so this returns undefined there and the fs path is never\n *  taken — Workers always reach the loader through the Vite glob map. A static\n *  `import 'node:fs'` would break Vite SSR bundling in the consumer apps, so it\n *  is deliberately avoided. */\nfunction nodeBuiltins():\n  | { fs: typeof import('node:fs'); path: typeof import('node:path'); url: typeof import('node:url') }\n  | undefined {\n  const getBuiltin = (globalThis as { process?: { getBuiltinModule?: (id: string) => unknown } })\n    .process?.getBuiltinModule\n  if (typeof getBuiltin !== 'function') return undefined\n  return {\n    fs: getBuiltin('node:fs') as typeof import('node:fs'),\n    path: getBuiltin('node:path') as typeof import('node:path'),\n    url: getBuiltin('node:url') as typeof import('node:url'),\n  }\n}\n\n/** Options for {@link loadMarkdownCorpus}. */\nexport interface LoadCorpusOptions {\n  /** The anchor folder name that appears in both glob keys and fs paths\n   *  (`skills`, `doctrine`, `knowledge`). Used to normalize keys + derive ids. */\n  anchor: string\n  /** Vite glob-result map. When present and non-empty it is authoritative and\n   *  the fs path is skipped. Omit it (or pass an empty map) only outside Vite. */\n  globModules?: GlobModules\n  /** Absolute or `import.meta.url`-relative base dir the fs fallback walks when\n   *  `globModules` is empty. Required for the fs path to run; without it the fs\n   *  fallback returns no entries (Workers never need it). */\n  fsBaseDir?: string\n  /** Walk strategy for the fs fallback. `nested` finds `<dir>/<slug>/SKILL.md`\n   *  one level deep; `flat` recurses for every `*.md`. Default: `flat`. */\n  fsLayout?: 'nested' | 'flat'\n  /** Drop an entry by its normalized key after load. Covers the per-product\n   *  skip lists (corpus index/log files, scaffold templates, allow-lists). */\n  skip?: (normalizedKey: string) => boolean\n}\n\n/** Outcome of {@link loadMarkdownCorpus}: the entries plus which path produced\n *  them, so a caller can fail loud when both are empty rather than silently\n *  mounting nothing. */\nexport interface CorpusLoadResult {\n  source: 'vite' | 'fs' | 'empty'\n  entries: CorpusEntry[]\n}\n\nfunction fsWalkFlat(\n  builtins: NonNullable<ReturnType<typeof nodeBuiltins>>,\n  root: string,\n): GlobModules {\n  const { fs, path } = builtins\n  const out: GlobModules = {}\n  if (!fs.existsSync(root)) return out\n  const walk = (dir: string) => {\n    let entries: import('node:fs').Dirent[]\n    try {\n      entries = fs.readdirSync(dir, { withFileTypes: true })\n    } catch {\n      return\n    }\n    for (const entry of entries) {\n      if (entry.name.startsWith('.')) continue\n      const full = path.join(dir, entry.name)\n      if (entry.isDirectory()) walk(full)\n      else if (entry.isFile() && entry.name.endsWith('.md')) out[full] = fs.readFileSync(full, 'utf8')\n    }\n  }\n  walk(root)\n  return out\n}\n\nfunction fsWalkNested(\n  builtins: NonNullable<ReturnType<typeof nodeBuiltins>>,\n  root: string,\n): GlobModules {\n  const { fs, path } = builtins\n  const out: GlobModules = {}\n  if (!fs.existsSync(root)) return out\n  let entries: import('node:fs').Dirent[]\n  try {\n    entries = fs.readdirSync(root, { withFileTypes: true })\n  } catch {\n    return out\n  }\n  for (const entry of entries) {\n    if (!entry.isDirectory()) continue\n    const skillFile = path.join(root, entry.name, 'SKILL.md')\n    if (!fs.existsSync(skillFile)) continue\n    out[skillFile] = fs.readFileSync(skillFile, 'utf8')\n  }\n  return out\n}\n\n/** Resolve `fsBaseDir` against `import.meta.url` when relative-looking, so a\n *  consumer can pass a bare folder name (`'skills'`) and have it land beside\n *  the calling module. Absolute paths pass through. */\nfunction resolveFsBase(\n  builtins: NonNullable<ReturnType<typeof nodeBuiltins>>,\n  fsBaseDir: string,\n  importMetaUrl?: string,\n): string {\n  const { path, url } = builtins\n  if (path.isAbsolute(fsBaseDir)) return fsBaseDir\n  const here = importMetaUrl\n    ? path.dirname(url.fileURLToPath(importMetaUrl))\n    : process.cwd()\n  return path.join(here, fsBaseDir)\n}\n\n/**\n * Load a markdown corpus, preferring a Vite glob-result map and falling back to\n * a Node fs walk. Selection is by non-empty glob result — never an env flag.\n * Entries are normalized, optionally skip-filtered, and sorted by id for\n * determinism. The `import.meta.glob` literal stays at the CONSUMER call site\n * (passed in as `globModules`); this loader never constructs a glob.\n */\nexport function loadMarkdownCorpus(\n  options: LoadCorpusOptions,\n  importMetaUrl?: string,\n): CorpusLoadResult {\n  const { anchor, globModules, fsBaseDir, fsLayout = 'flat', skip } = options\n\n  let modules: GlobModules\n  let source: CorpusLoadResult['source']\n  if (globModules && Object.keys(globModules).length > 0) {\n    modules = globModules\n    source = 'vite'\n  } else {\n    const builtins = nodeBuiltins()\n    if (builtins && fsBaseDir) {\n      const root = resolveFsBase(builtins, fsBaseDir, importMetaUrl)\n      modules = fsLayout === 'nested' ? fsWalkNested(builtins, root) : fsWalkFlat(builtins, root)\n      source = Object.keys(modules).length > 0 ? 'fs' : 'empty'\n    } else {\n      modules = {}\n      source = 'empty'\n    }\n  }\n\n  const entries: CorpusEntry[] = []\n  for (const [rawKey, content] of Object.entries(modules)) {\n    if (typeof content !== 'string') continue\n    const key = normalizeKey(rawKey, anchor)\n    if (skip && skip(key)) continue\n    entries.push({ id: toCorpusId(key, anchor), key, content })\n  }\n  entries.sort((a, b) => a.id.localeCompare(b.id))\n  return { source, entries }\n}\n\n/** Project corpus entries onto SDK file mounts at a relative path under\n *  `<anchor>/`. Always-mounted: the corpus is the agent's baseline knowledge. */\nexport function corpusSkills(corpus: CorpusEntry[], anchor: string): AgentProfileFileMount[] {\n  return corpus\n    .map(\n      (entry) =>\n        ({\n          path: `${anchor}/${entry.id}.md`,\n          resource: inlineResource(`${anchor}-${entry.id}`, entry.content),\n        }) satisfies AgentProfileFileMount,\n    )\n    .sort((a, b) => a.path.localeCompare(b.path))\n}\n\n/** Project the registry's free-tier (or `tier`-matched) entries onto SDK file\n *  mounts at the harness skill-discovery path. Tier-gating is the registry's\n *  only selection rule — paid skills are installed on demand, not at boot. */\nexport function registrySkills(\n  registry: SkillEntry[],\n  tier: string = 'free',\n): AgentProfileFileMount[] {\n  return registry\n    .filter((s) => s.tier === tier)\n    .map(\n      (s) =>\n        ({\n          path: skillMountPath(s.id),\n          resource: inlineResource(s.id, s.skillMd),\n        }) satisfies AgentProfileFileMount,\n    )\n    .sort((a, b) => a.path.localeCompare(b.path))\n}\n\n/** Inputs to {@link composeShellResources}. Each channel is optional so a\n *  product mounts only the systems it has — corpus-only, registry-only, or\n *  both — without conflating them. */\nexport interface ComposeShellResourcesInput {\n  /** Corpus mounts (always-mounted baseline). Pass the result of\n   *  {@link corpusSkills}, or a hand-built mount list. */\n  skills?: AgentProfileFileMount[]\n  /** Knowledge-corpus mounts (a second always-mounted corpus, e.g. a domain\n   *  knowledge pack distinct from the skills corpus). */\n  knowledge?: AgentProfileFileMount[]\n  /** Evolvable / learned-guidance mounts (single-file corpora). */\n  evolvable?: AgentProfileFileMount[]\n  /** Registry mounts (tier-gated). Pass the result of {@link registrySkills}. */\n  registry?: AgentProfileFileMount[]\n  /** Final skip filter applied to the composed mount list by mount `path`. */\n  predicate?: (mount: AgentProfileFileMount) => boolean\n}\n\n/**\n * Compose every mount channel into one `resources.files`-ready array. Corpus\n * channels come first (baseline), the tier-gated registry last (so a registry\n * entry can override a corpus entry that mounts at the same path). The result\n * is exactly `AgentProfileFileMount[]` — assign it straight into\n * `profile.resources.files` with no cast.\n */\nexport function composeShellResources(input: ComposeShellResourcesInput): AgentProfileFileMount[] {\n  const { skills = [], knowledge = [], evolvable = [], registry = [], predicate } = input\n  const composed = [...skills, ...knowledge, ...evolvable, ...registry]\n  return predicate ? composed.filter(predicate) : composed\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tools/index.d.ts

@@ -1,7 +1,8 @@
-import { b as AppToolName, f as ToolHeaderNames } from '../mcp-eZCmkgCF.js';
-export { A as APP_TOOL_NAMES, a as AppToolMcpServer, c as AuthenticateOptions, B as BuildHttpMcpServerOptions, d as BuildMcpServerOptions, D as DEFAULT_APP_TOOL_PATHS, e as DEFAULT_HEADER_NAMES, O as OpenAIFunctionTool, T as ToolAuthResult, g as authenticateToolRequest, h as buildAppToolMcpServer, i as buildAppToolOpenAITools, j as buildHttpMcpServer, k as isAppToolName, r as readToolArgs } from '../mcp-eZCmkgCF.js';
+import { a as AppToolName, c as ToolHeaderNames } from '../auth-BlS9GWfL.js';
+export { A as APP_TOOL_NAMES, b as AuthenticateOptions, D as DEFAULT_HEADER_NAMES, O as OpenAIFunctionTool, T as ToolAuthResult, d as authenticateToolRequest, e as buildAppToolOpenAITools, i as isAppToolName, r as readToolArgs } from '../auth-BlS9GWfL.js';
 import { f as AppToolTaxonomy, c as AppToolHandlers, b as AppToolContext, e as AppToolProducedEvent, d as AppToolOutcome } from '../types-2rOJo8Hc.js';
 export { A as AddCitationArgs, a as AddCitationResult, R as RenderUiArgs, g as RenderUiResult, S as ScheduleFollowupArgs, h as ScheduleFollowupResult, i as SubmitProposalArgs, j as SubmitProposalResult } from '../types-2rOJo8Hc.js';
+export { A as AppToolMcpServer, B as BuildHttpMcpServerOptions, a as BuildMcpServerOptions, D as DEFAULT_APP_TOOL_PATHS, b as buildAppToolMcpServer, c as buildHttpMcpServer } from '../mcp-BShTlESm.js';
 export { C as CreateMcpToolHandlerOptions, M as MCP_PROTOCOL_VERSIONS, a as McpProtocolVersion, b as McpServerInfo, c as McpToolDefinition, d as createMcpToolHandler } from '../mcp-rpc-DLw_r9PQ.js';
 
 /** A correctable bad-input error a tool handler throws; the HTTP layer maps it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "packageManager": "pnpm@10.33.4",
   "description": "Application-shell framework for Tangle agent products: a bounded tool loop, the structured agent→app tool side channel, integration-hub client, per-workspace billing, and crypto — composed over the Tangle agent substrate through typed seams.",
   "keywords": [
@@ -82,6 +82,31 @@
       "import": "./dist/skills/index.js",
       "default": "./dist/skills/index.js"
     },
+    "./profile": {
+      "types": "./dist/profile/index.d.ts",
+      "import": "./dist/profile/index.js",
+      "default": "./dist/profile/index.js"
+    },
+    "./prompt": {
+      "types": "./dist/prompt/index.d.ts",
+      "import": "./dist/prompt/index.js",
+      "default": "./dist/prompt/index.js"
+    },
+    "./model-resolution": {
+      "types": "./dist/model-resolution/index.d.ts",
+      "import": "./dist/model-resolution/index.js",
+      "default": "./dist/model-resolution/index.js"
+    },
+    "./sandbox": {
+      "types": "./dist/sandbox/index.d.ts",
+      "import": "./dist/sandbox/index.js",
+      "default": "./dist/sandbox/index.js"
+    },
+    "./run": {
+      "types": "./dist/run/index.d.ts",
+      "import": "./dist/run/index.js",
+      "default": "./dist/run/index.js"
+    },
     "./config": {
       "types": "./dist/config/index.d.ts",
       "import": "./dist/config/index.js",