create-loopengine 0.1.12 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loopengine",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Scaffold a new loopengine agent project — a runnable HTTP server with one example agent, in your own repo.",
   "license": "MIT",
   "type": "module",

package/template/adapters/http.ts

@@ -43,6 +43,7 @@ import {
   AgentEditNotSupportedError,
   AgentFileNotFoundError,
   type AgentEditResult,
+  type AgentEditableFields,
   createSessionStore,
   createCheckpointStore,
   type TurnCheckpoint,
@@ -79,6 +80,10 @@ import {
   deleteSkill,
   SkillInvalidIdError,
   SkillNotFoundError,
+  listSkillgardenCatalog,
+  readSkillgardenCatalogEntry,
+  addSkillgardenSkillToAgent,
+  SkillgardenUnavailableError,
   readActauthConfig,
   addActauthRule,
   updateActauthRule,
@@ -314,9 +319,14 @@ async function describeAgent(entry: RegistryEntry): Promise<Record<string, unkno
   // configured for *this* agent, so the config page's own Skills tab
   // deliberately doesn't mix it into skills/skillsDirs below.
   const skillsDirs = config.skillsDirs ?? [`agents/${config.name}/skills`]
-  const skillGarden = new SkillGarden({ dirs: skillsDirs, indexBudgetTokens: config.skillIndexBudgetTokens ?? 200 })
+  // Same defaults, same reasoning, as loopengine's own run-agent.ts
+  // SkillGarden/BudgetTracker construction — kept in sync there and here
+  // since this is what a "Skills"/"Limits & budgets" tab shows an
+  // operator, and it has to describe what runAgent() would actually
+  // resolve, not a second guess (see this function's own header comment).
+  const skillGarden = new SkillGarden({ dirs: skillsDirs, indexBudgetTokens: config.skillIndexBudgetTokens ?? 2000 })
   const skillIndex = skillGarden.buildIndex().included
-  const systemSkillGarden = new SkillGarden({ dirs: [systemSkillsDir], indexBudgetTokens: config.skillIndexBudgetTokens ?? 200 })
+  const systemSkillGarden = new SkillGarden({ dirs: [systemSkillsDir], indexBudgetTokens: config.skillIndexBudgetTokens ?? 2000 })
   const systemSkillIndex = systemSkillGarden.buildIndex().included
 
   return {
@@ -326,8 +336,8 @@ async function describeAgent(entry: RegistryEntry): Promise<Record<string, unkno
       ? { provider: config.model.provider, model: config.model.model, maxTokens: config.model.maxTokens }
       : 'custom (module exports its own createModelCall)',
     maxTurns: config.maxTurns ?? 25,
-    contextBudgetTokens: config.contextBudgetTokens ?? 8000,
-    skillIndexBudgetTokens: config.skillIndexBudgetTokens ?? 200,
+    contextBudgetTokens: config.contextBudgetTokens ?? 100000,
+    skillIndexBudgetTokens: config.skillIndexBudgetTokens ?? 2000,
     skillsDirs: skillsDirs,
     skills: skillIndex.map((s) => ({ name: s.name, description: s.description })),
     systemSkills: systemSkillIndex.map((s) => ({ name: s.name, description: s.description })),
@@ -644,6 +654,33 @@ function parseAgentTemplateOptions(body: Record<string, unknown>): { ok: true; v
   return { ok: true, value: options }
 }
 
+// The Overview tab's "Limits & budgets" edit form — kept separate from
+// parseAgentTemplateOptions since that one's shape (AgentTemplateOptions)
+// is shared with handleCreateAgent/scaffoldAgent, which has no notion of
+// these three at all (a freshly scaffolded agent always starts on
+// loopengine's own defaults — see AgentConfig's own doc comments). Each
+// of the three is optional and independent, same as systemPrompt/model
+// above.
+function parsePositiveInt(value: unknown, field: string): { ok: true; value: number | undefined } | { ok: false; error: string } {
+  if (value === undefined || value === null) return { ok: true, value: undefined }
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < 1) {
+    return { ok: false, error: `${field} must be a positive integer` }
+  }
+  return { ok: true, value }
+}
+
+function parseAgentLimitsFields(
+  body: Record<string, unknown>,
+): { ok: true; value: Pick<AgentEditableFields, 'maxTurns' | 'contextBudgetTokens' | 'skillIndexBudgetTokens'> } | { ok: false; error: string } {
+  const value: Pick<AgentEditableFields, 'maxTurns' | 'contextBudgetTokens' | 'skillIndexBudgetTokens'> = {}
+  for (const field of ['maxTurns', 'contextBudgetTokens', 'skillIndexBudgetTokens'] as const) {
+    const parsed = parsePositiveInt(body[field], field)
+    if (!parsed.ok) return parsed
+    if (parsed.value !== undefined) value[field] = parsed.value
+  }
+  return { ok: true, value }
+}
+
 async function handleCreateAgent(req: IncomingMessage, res: ServerResponse): Promise<void> {
   const body = await readJsonBody(req)
   if (typeof body.name !== 'string' || !body.name) {
@@ -677,9 +714,11 @@ async function handleCreateAgent(req: IncomingMessage, res: ServerResponse): Pro
   res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ path: indexPath, registered: true }))
 }
 
-// Backs the Overview tab's System prompt / Model edit forms — either
-// field can be sent independently (see parseAgentTemplateOptions), the
-// other stays untouched both on disk and live. Persists via
+// Backs the Overview tab's System prompt / Model / Limits & budgets edit
+// forms — any subset of systemPrompt, model, maxTurns, contextBudgetTokens,
+// skillIndexBudgetTokens can be sent independently (see
+// parseAgentTemplateOptions/parseAgentLimitsFields), every other field
+// stays untouched both on disk and live. Persists via
 // agent-file-admin.ts's editAgentFile (see its own doc comment for why
 // this is a surgical AST edit, not a full file regeneration), then
 // applies the exact same resolved values to *this* running process via
@@ -699,14 +738,22 @@ async function handleEditAgent(req: IncomingMessage, res: ServerResponse, agentN
     res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: parsedOptions.error }))
     return
   }
-  if (parsedOptions.value.systemPrompt === undefined && parsedOptions.value.model === undefined) {
-    res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: 'systemPrompt or model is required' }))
+  const parsedLimits = parseAgentLimitsFields(body)
+  if (!parsedLimits.ok) {
+    res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: parsedLimits.error }))
+    return
+  }
+  const editFields: AgentEditableFields = { ...parsedOptions.value, ...parsedLimits.value }
+  if (Object.keys(editFields).length === 0) {
+    res
+      .writeHead(400, { 'content-type': 'application/json' })
+      .end(JSON.stringify({ error: 'systemPrompt, model, maxTurns, contextBudgetTokens, or skillIndexBudgetTokens is required' }))
     return
   }
 
   let result: AgentEditResult
   try {
-    result = editAgentFile(agentName, parsedOptions.value)
+    result = editAgentFile(agentName, editFields)
   } catch (err) {
     const status =
       err instanceof AgentEditNotSupportedError || err instanceof AgentModelError ? 400 : err instanceof AgentFileNotFoundError ? 404 : 500
@@ -716,6 +763,9 @@ async function handleEditAgent(req: IncomingMessage, res: ServerResponse, agentN
 
   const configPatch: Partial<AgentConfig> = {}
   if (result.systemPrompt !== undefined) configPatch.systemPrompt = result.systemPrompt
+  if (result.maxTurns !== undefined) configPatch.maxTurns = result.maxTurns
+  if (result.contextBudgetTokens !== undefined) configPatch.contextBudgetTokens = result.contextBudgetTokens
+  if (result.skillIndexBudgetTokens !== undefined) configPatch.skillIndexBudgetTokens = result.skillIndexBudgetTokens
   let createModelCall: RegistryEntry['createModelCall'] | undefined
   if (result.model) {
     configPatch.model = result.model
@@ -782,6 +832,69 @@ function handleSkillDelete(res: ServerResponse, agentName: string, skillId: stri
   res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ ok: true }))
 }
 
+// Backs the Skills tab's "Browse skillgarden catalog" section — a
+// read-only, agent-independent list of everything skillgarden ships in
+// its own bundled registry (see loopengine's own web/skillgarden-admin.ts).
+// Not wrapped in a per-agent :name segment since the catalog itself
+// isn't scoped to any one agent; only the POST below (actually
+// installing an entry) is.
+function handleSkillgardenCatalogGet(res: ServerResponse): void {
+  try {
+    // Computed before writeHead, not inlined into .end()'s own argument —
+    // res.writeHead(200, ...) commits the status line the instant it's
+    // called, so a throw evaluated *after* it (as it would be if it were
+    // inlined as .end()'s argument) leaves headers already sent as 200
+    // with no body, and the catch block's own writeHead(status, ...)
+    // then fails outright (ERR_HTTP_HEADERS_SENT) instead of ever
+    // reaching the client.
+    const catalog = listSkillgardenCatalog()
+    res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(catalog))
+  } catch (err) {
+    const status = err instanceof SkillgardenUnavailableError ? 503 : 500
+    res.writeHead(status, { 'content-type': 'application/json' }).end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
+  }
+}
+
+// Full SKILL.md body for the catalog's own "View" toggle — kept as a
+// separate route from the list above (rather than inlining every body
+// into it) for the same reason the Skills tab's own edit form fetches a
+// skill's body lazily instead of shipping it in the initial list.
+function handleSkillgardenCatalogEntryGet(res: ServerResponse, category: string, id: string): void {
+  try {
+    // See handleSkillgardenCatalogGet's own comment for why this is
+    // computed before writeHead rather than inlined into .end()'s
+    // argument.
+    const entry = readSkillgardenCatalogEntry(category, id)
+    res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(entry))
+  } catch (err) {
+    const status = err instanceof SkillgardenUnavailableError ? 503 : 404
+    res.writeHead(status, { 'content-type': 'application/json' }).end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
+  }
+}
+
+// Installs a catalog entry into agents/:name/skills/ — delegates to
+// skillgarden's own addSkill (see skillgarden-admin.ts), which throws
+// plain Errors (no typed classes) for "unknown skill"/"already exists",
+// so those two are told apart by message shape rather than instanceof,
+// same as any other dependency that doesn't export typed errors for its
+// own failure modes.
+async function handleSkillgardenCatalogAdd(req: IncomingMessage, res: ServerResponse, agentName: string, category: string, id: string): Promise<void> {
+  if (!getEntry(agentName)) {
+    res.writeHead(404, { 'content-type': 'application/json' }).end(JSON.stringify({ error: `unknown agent '${agentName}'` }))
+    return
+  }
+  const body = await readJsonBody(req)
+  const force = body.force === true
+  try {
+    const result = addSkillgardenSkillToAgent(agentName, category, id, force)
+    res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ ok: true, id: result.id }))
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    const status = err instanceof SkillgardenUnavailableError ? 503 : /already exists/.test(message) ? 409 : /^Unknown skill/.test(message) ? 404 : 500
+    res.writeHead(status, { 'content-type': 'application/json' }).end(JSON.stringify({ error: message }))
+  }
+}
+
 // Backs the Actauth tab's rule editor — parses a rule body shared by both
 // the add (POST) and update (PUT, minus `name`) routes below.
 function parseActauthRuleBody(body: Record<string, unknown>, requireName: boolean): { ok: true; value: { name: string; scope: string; tool: string; decision: Decision } } | { ok: false; error: string } {
@@ -1906,6 +2019,23 @@ const server = createServer(async (req, res) => {
       return
     }
 
+    // Backs the Skills tab's "Browse skillgarden catalog" section — see
+    // the three handlers above it.
+    if (req.method === 'GET' && pathname === '/skillgarden-catalog') {
+      handleSkillgardenCatalogGet(res)
+      return
+    }
+    const skillgardenEntryMatch = req.method === 'GET' && pathname.match(/^\/skillgarden-catalog\/([^/]+)\/([^/]+)$/)
+    if (skillgardenEntryMatch) {
+      handleSkillgardenCatalogEntryGet(res, decodeURIComponent(skillgardenEntryMatch[1]), decodeURIComponent(skillgardenEntryMatch[2]))
+      return
+    }
+    const skillgardenAddMatch = req.method === 'POST' && pathname.match(/^\/agents\/([^/]+)\/skillgarden-catalog\/([^/]+)\/([^/]+)$/)
+    if (skillgardenAddMatch) {
+      await handleSkillgardenCatalogAdd(req, res, decodeURIComponent(skillgardenAddMatch[1]), decodeURIComponent(skillgardenAddMatch[2]), decodeURIComponent(skillgardenAddMatch[3]))
+      return
+    }
+
     // Backs the Actauth tab's rule editor and default_decision control.
     // The default-decision route is checked before the :ruleName routes
     // right below since 'default-decision' would otherwise itself match

package/template/package.json

@@ -9,9 +9,9 @@
     "cli": "tsx adapters/cli.ts"
   },
   "dependencies": {
-    "loopengine": "^0.1.4",
+    "loopengine": "^0.1.6",
     "actauth": "^0.0.12",
-    "skillgarden": "^0.0.5"
+    "skillgarden": "^0.0.9"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",