blun-king-cli 9.1.471 → 9.1.473

package/bin/agent-api-http-adapter.mjs

@@ -1,4 +1,5 @@
 const AGENT_TURNS_PATH = '/v1/agent/turns';
+const AGENT_SESSIONS_PATH = '/v1/agent/sessions';
 const PUBLIC_MODEL_ID = 'king';
 const PUBLIC_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/u;
 
@@ -70,9 +71,26 @@ function decodeRequestId(value) {
   return requirePublicId(decoded, 'request ID');
 }
 
+function decodeSessionId(value) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+    throw adapterError('AGENT_API_INVALID_ID', 'session ID is not valid URL encoding');
+  }
+  return requirePublicId(decoded, 'session ID');
+}
+
 function routeFor(method, rawPath) {
   const path = String(rawPath ?? '').split('?', 1)[0];
   if (method === 'POST' && path === AGENT_TURNS_PATH) return { kind: 'start' };
+  if (path.startsWith(`${AGENT_SESSIONS_PATH}/`)) {
+    const tail = path.slice(AGENT_SESSIONS_PATH.length + 1);
+    if (method === 'DELETE' && !tail.includes('/')) {
+      return { kind: 'closeSession', sessionId: decodeSessionId(tail) };
+    }
+    return { kind: 'unknown' };
+  }
   if (!path.startsWith(`${AGENT_TURNS_PATH}/`)) {
     if (path.startsWith('/v1/agent/')) return { kind: 'unknown' };
     return null;
@@ -207,8 +225,19 @@ function createAgentApiHttpAdapter(options = {}) {
   if (typeof options.resolveSession !== 'function') {
     throw new TypeError('resolveSession must be a function');
   }
+  if (typeof options.closeSession !== 'function') {
+    throw new TypeError('closeSession must be a function');
+  }
   const owners = new Map();
 
+  function hasActiveOwner(principalId, sessionId) {
+    const prefix = `${sessionId}\0`;
+    for (const [key, scopeOwners] of owners) {
+      if (key.startsWith(prefix) && scopeOwners.has(principalId)) return true;
+    }
+    return false;
+  }
+
   function requireOwner(principalId, sessionId, requestId) {
     const key = scopeKey(sessionId, requestId);
     const scopeOwners = owners.get(key);
@@ -242,6 +271,12 @@ function createAgentApiHttpAdapter(options = {}) {
     if (scopeOwners?.size === 0) owners.delete(key);
   }
 
+  function trackRunningScope(key, principalId, internalSessionId) {
+    const scopeOwners = owners.get(key) ?? new Map();
+    scopeOwners.set(principalId, internalSessionId);
+    owners.set(key, scopeOwners);
+  }
+
   async function handleStart(input, principalId) {
     const body = requireBody(input.body);
     requireKing(body.model);
@@ -266,20 +301,24 @@ function createAgentApiHttpAdapter(options = {}) {
       );
     }
     const internalSessionId = session.id.trim();
-    const response = publicCompletion(await controller.startTurn({
-      session,
-      publicSessionId: sessionId,
-      requestId,
-      prompt: normalizePrompt(body.input),
-      tools: normalizeTools(body.tools),
-    }));
-    trackScope(
-      scopeKey(sessionId, requestId),
-      principalId,
-      internalSessionId,
-      response,
-    );
-    return jsonResponse(200, response);
+    const prompt = normalizePrompt(body.input);
+    const tools = normalizeTools(body.tools);
+    const key = scopeKey(sessionId, requestId);
+    trackRunningScope(key, principalId, internalSessionId);
+    try {
+      const response = publicCompletion(await controller.startTurn({
+        session,
+        publicSessionId: sessionId,
+        requestId,
+        prompt,
+        tools,
+      }));
+      trackScope(key, principalId, internalSessionId, response);
+      return jsonResponse(200, response);
+    } catch (error) {
+      trackScope(key, principalId, internalSessionId, null);
+      throw error;
+    }
   }
 
   async function handleContinue(input, principalId, requestId) {
@@ -313,6 +352,31 @@ function createAgentApiHttpAdapter(options = {}) {
     });
   }
 
+  async function handleCloseSession(principalId, sessionId) {
+    if (hasActiveOwner(principalId, sessionId)) {
+      throw adapterError(
+        'AGENT_API_SESSION_BUSY',
+        'Agent session has an active turn.',
+        409,
+      );
+    }
+    const closed = await options.closeSession({ principalId, sessionId });
+    if (closed !== true) {
+      throw adapterError(
+        'AGENT_API_SESSION_NOT_FOUND',
+        'Agent session was not found.',
+        404,
+      );
+    }
+    return jsonResponse(200, {
+      id: `agent-session-${sessionId}`,
+      object: 'agent.session.closed',
+      model: PUBLIC_MODEL_ID,
+      session_id: sessionId,
+      closed: true,
+    });
+  }
+
   async function handleRequest(input) {
     if (input === null || typeof input !== 'object') return null;
     const method = String(input.method ?? '').toUpperCase();
@@ -331,6 +395,9 @@ function createAgentApiHttpAdapter(options = {}) {
       }
       const principalId = requireTrustedId(input.principalId, 'principalId');
       if (route.kind === 'start') return await handleStart(input, principalId);
+      if (route.kind === 'closeSession') {
+        return await handleCloseSession(principalId, route.sessionId);
+      }
       if (route.kind === 'continue') {
         return await handleContinue(input, principalId, route.requestId);
       }
@@ -344,6 +411,7 @@ function createAgentApiHttpAdapter(options = {}) {
 }
 
 export {
+  AGENT_SESSIONS_PATH,
   AGENT_TURNS_PATH,
   AgentApiHttpAdapterError,
   PUBLIC_MODEL_ID,

package/bin/agent-api-service-host.mjs

@@ -125,6 +125,7 @@ function createAgentApiServiceHost(options = {}) {
   const adapter = createAgentApiHttpAdapter({
     controller,
     resolveSession: sessionRegistry.resolveSession,
+    closeSession: sessionRegistry.closeSession,
   });
   const privateServer = createAgentApiPrivateHttpServer({
     adapter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.471",
+  "version": "9.1.473",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {