create-loopengine 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loopengine",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "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

@@ -36,9 +36,14 @@ import {
   synthesizeCreateModelCall,
   editAgentFile,
   createHttpTool,
+  updateHttpTool,
+  readHttpToolSpec,
+  listEditableHttpToolNames,
   HttpToolNameError,
   HttpToolExistsError,
   HttpToolIndexShapeError,
+  HttpToolNotFoundError,
+  HttpToolNotEditableError,
   type HttpToolSpec,
   AgentEditNotSupportedError,
   AgentFileNotFoundError,
@@ -290,6 +295,10 @@ function describeTool(t: { name: string; description: string; safe?: boolean; in
 
 async function describeAgent(entry: RegistryEntry): Promise<Record<string, unknown>> {
   const { config } = entry
+  // Which localTools the Tools tab's Edit button applies to — only the
+  // ones with a saved spec (loopengine's own sidecar spec file), i.e.
+  // only tools this same admin UI generated in the first place.
+  const editableHttpToolNames = new Set(listEditableHttpToolNames(config.name))
   // Kept separate (not just concatenated into one `tools` array — though
   // that's still returned too, below, for Overview's own at-a-glance
   // count) so the "Tools" tab can show where each one actually comes
@@ -346,7 +355,7 @@ async function describeAgent(entry: RegistryEntry): Promise<Record<string, unkno
     // schema here — never executed, so the console-prompt fallback its
     // own doc comment mentions never applies to this call.
     systemTools: [...systemTools, createAskUserTool({ agent: config.name })].map(describeTool),
-    localTools: localTools.map(describeTool),
+    localTools: localTools.map((t) => ({ ...describeTool(t), httpToolEditable: editableHttpToolNames.has(t.name) })),
     agentAsTools: agentAsTools.map(describeTool),
     gatewayTools: gatewayTools.map(describeTool),
     permissions: {
@@ -524,6 +533,13 @@ async function handleHttpToolPost(req: IncomingMessage, res: ServerResponse, age
     return
   }
 
+  // Resolved *before* createHttpTool writes anything to disk. Reading it
+  // after would risk a cold import of the freshly-written tools/index.ts
+  // (folder-form agents don't cache config.tools) — which already contains
+  // the new tool by then, so the ...currentTools, tool below would append
+  // it a second time.
+  const currentTools = entry.config.tools ?? (await loadDefaultTools(entry.config))
+
   let tool: ToolDefinition
   try {
     const result = await createHttpTool(agentName, parsed.value)
@@ -534,7 +550,6 @@ async function handleHttpToolPost(req: IncomingMessage, res: ServerResponse, age
     return
   }
 
-  const currentTools = entry.config.tools ?? (await loadDefaultTools(entry.config))
   updateAgent(agentName, { config: { tools: [...currentTools, tool] } })
 
   if (parsed.decision) {
@@ -556,6 +571,72 @@ async function handleHttpToolPost(req: IncomingMessage, res: ServerResponse, age
   res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ tool: describeTool(tool) }))
 }
 
+// Backs the Tools tab's Edit button on a Local tool: GET populates the
+// form from the spec createHttpTool/updateHttpTool saved alongside the
+// generated file, PUT saves it back. 404s for any tool without a saved
+// spec (hand-written, or created before this sidecar existed) — same
+// signal describeAgent's own httpToolEditable flag uses to decide
+// whether to show the button at all, so this only ever rejects a request
+// the UI itself shouldn't have been able to send.
+function handleHttpToolGet(res: ServerResponse, agentName: string, toolName: string): void {
+  if (!getEntry(agentName)) {
+    res.writeHead(404, { 'content-type': 'application/json' }).end(JSON.stringify({ error: `unknown agent '${agentName}'` }))
+    return
+  }
+  const spec = readHttpToolSpec(agentName, toolName)
+  if (!spec) {
+    res.writeHead(404, { 'content-type': 'application/json' }).end(
+      JSON.stringify({ error: `No admin-created HTTP tool named '${toolName}' for '${agentName}' — hand-written tools aren't editable through this form.` }),
+    )
+    return
+  }
+  res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(spec))
+}
+
+async function handleHttpToolPut(req: IncomingMessage, res: ServerResponse, agentName: string, toolName: string): Promise<void> {
+  const entry = getEntry(agentName)
+  if (!entry) {
+    res.writeHead(404, { 'content-type': 'application/json' }).end(JSON.stringify({ error: `unknown agent '${agentName}'` }))
+    return
+  }
+  const body = await readJsonBody(req)
+  const parsed = parseHttpToolBody(body)
+  if (!parsed.ok) {
+    res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: parsed.error }))
+    return
+  }
+
+  // Same ordering reasoning as handleHttpToolPost above: resolved before
+  // updateHttpTool touches disk.
+  const currentTools = entry.config.tools ?? (await loadDefaultTools(entry.config))
+
+  let tool: ToolDefinition
+  try {
+    const result = await updateHttpTool(agentName, toolName, parsed.value)
+    tool = result.tool
+  } catch (err) {
+    const status =
+      err instanceof HttpToolNotFoundError || err instanceof HttpToolNotEditableError
+        ? 409
+        : err instanceof HttpToolNameError || err instanceof HttpToolIndexShapeError
+          ? 400
+          : 500
+    res.writeHead(status, { 'content-type': 'application/json' }).end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
+    return
+  }
+
+  // Replaces the edited tool in place (same array position, same
+  // reference identity for everything else) rather than the create
+  // path's append — an edit doesn't seed a new actauth rule either,
+  // unlike creation: the tool's permission is unchanged by this, still
+  // governed by whatever rule (if any) creation seeded or an operator
+  // added since, editable separately via the Actauth tab.
+  const nextTools = currentTools.map((t) => (t.name === toolName ? tool : t))
+  updateAgent(agentName, { config: { tools: nextTools } })
+
+  res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ tool: describeTool(tool) }))
+}
+
 // Backs GET /composio/connections and GET /composio/tools — not scoped
 // under /agents/:name/ like the routes above, deliberately: which apps
 // are connected and what they offer isn't a property of any one agent,
@@ -2010,6 +2091,18 @@ const server = createServer(async (req, res) => {
       return
     }
 
+    // Backs the Tools tab's Edit button on a Local tool — GET to populate
+    // the form, PUT to save (see handleHttpToolGet/Put above).
+    const httpToolItemMatch = pathname.match(/^\/agents\/([^/]+)\/tools\/http\/([^/]+)$/)
+    if (httpToolItemMatch && req.method === 'GET') {
+      handleHttpToolGet(res, decodeURIComponent(httpToolItemMatch[1]), decodeURIComponent(httpToolItemMatch[2]))
+      return
+    }
+    if (httpToolItemMatch && req.method === 'PUT') {
+      await handleHttpToolPut(req, res, decodeURIComponent(httpToolItemMatch[1]), decodeURIComponent(httpToolItemMatch[2]))
+      return
+    }
+
     // Backs the Skills tab's edit form — see skills-admin.ts for why
     // :skillId is restricted to a flat (non-nested) id.
     const skillMatch = pathname.match(/^\/agents\/([^/]+)\/skills\/([^/]+)$/)