blun-king-cli 9.1.470 → 9.1.472

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);
@@ -313,6 +342,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 +385,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 +401,7 @@ function createAgentApiHttpAdapter(options = {}) {
 }
 
 export {
+  AGENT_SESSIONS_PATH,
   AGENT_TURNS_PATH,
   AgentApiHttpAdapterError,
   PUBLIC_MODEL_ID,

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

@@ -0,0 +1,199 @@
+import path from 'node:path';
+
+import { createAgentApiHttpAdapter } from './agent-api-http-adapter.mjs';
+import { createAgentApiPrivateHttpServer } from './agent-api-private-http-server.mjs';
+import { createAgentApiRuntime } from './agent-api-runtime.mjs';
+import { createAgentApiSessionRegistry } from './agent-api-session-registry.mjs';
+import { createAgentApiTurnController } from './agent-api-turn-controller.mjs';
+
+const MIN_SECRET_BYTES = 32;
+
+function requireSecret(value, label) {
+  if (typeof value !== 'string' || Buffer.byteLength(value, 'utf8') < MIN_SECRET_BYTES) {
+    throw new TypeError(`${label} must contain at least ${MIN_SECRET_BYTES} bytes`);
+  }
+  return value;
+}
+
+function requireAbsoluteRoot(value) {
+  if (typeof value !== 'string' || !path.isAbsolute(value)) {
+    throw new TypeError('rootDir must be an absolute path');
+  }
+  return path.resolve(value);
+}
+
+function requireObject(value, label) {
+  if (value === undefined) return {};
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object`);
+  }
+  return value;
+}
+
+function cloneHarnessConfig(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError('harnessConfig must be an object');
+  }
+  let config;
+  try {
+    config = structuredClone(value);
+  } catch {
+    throw new TypeError('harnessConfig must be structured-cloneable');
+  }
+  if (config.defaultModel !== 'king') {
+    throw new TypeError('harnessConfig.defaultModel must be king');
+  }
+  if (config.models === null
+    || typeof config.models !== 'object'
+    || Array.isArray(config.models)
+    || config.models.king === null
+    || typeof config.models.king !== 'object'
+    || Array.isArray(config.models.king)) {
+    throw new TypeError('harnessConfig.models.king must be an object');
+  }
+  const provider = config.models.king.provider;
+  if (typeof provider !== 'string'
+    || provider.length === 0
+    || config.providers === null
+    || typeof config.providers !== 'object'
+    || Array.isArray(config.providers)
+    || !Object.hasOwn(config.providers, provider)) {
+    throw new TypeError('harnessConfig must define the provider used by models.king');
+  }
+  return config;
+}
+
+async function createBundledHarness(input) {
+  const { createBlunHarness } = await import('../blun.mjs');
+  return createBlunHarness(input);
+}
+
+function resolveHarnessPreparation(options) {
+  const hasConfig = options.harnessConfig !== undefined;
+  const hasPrepare = options.prepareHarness !== undefined;
+  if (hasConfig && hasPrepare) {
+    throw new TypeError('only one of harnessConfig or prepareHarness may be provided');
+  }
+  if (!hasConfig && !hasPrepare) {
+    throw new TypeError('harnessConfig or prepareHarness is required');
+  }
+  if (hasPrepare) {
+    if (typeof options.prepareHarness !== 'function') {
+      throw new TypeError('prepareHarness must be a function');
+    }
+    return options.prepareHarness;
+  }
+
+  const config = cloneHarnessConfig(options.harnessConfig);
+  return async ({ harness }) => {
+    if (typeof harness?.setConfig !== 'function') {
+      throw new TypeError('Agent API harness must provide setConfig');
+    }
+    await harness.setConfig(structuredClone(config));
+  };
+}
+
+function createAgentApiServiceHost(options = {}) {
+  const rootDir = requireAbsoluteRoot(options.rootDir);
+  const internalSecret = requireSecret(options.internalSecret, 'internalSecret');
+  const isolationSecret = requireSecret(options.isolationSecret, 'isolationSecret');
+  if (internalSecret === isolationSecret) {
+    throw new TypeError('internalSecret and isolationSecret must be different');
+  }
+  if (options.createHarness !== undefined && typeof options.createHarness !== 'function') {
+    throw new TypeError('createHarness must be a function');
+  }
+
+  const runtimeOptions = requireObject(options.runtimeOptions, 'runtimeOptions');
+  const controllerOptions = requireObject(options.controllerOptions, 'controllerOptions');
+  const prepareHarness = resolveHarnessPreparation(options);
+  const runtime = createAgentApiRuntime(runtimeOptions);
+  const controller = createAgentApiTurnController({
+    ...controllerOptions,
+    runtime,
+    publicModel: 'king',
+  });
+  const sessionRegistry = createAgentApiSessionRegistry({
+    rootDir,
+    isolationSecret,
+    createHarness: options.createHarness ?? createBundledHarness,
+    prepareHarness,
+    sessionOptions: options.sessionOptions,
+    maxPrincipals: options.maxPrincipals,
+    maxSessionsPerPrincipal: options.maxSessionsPerPrincipal,
+  });
+  const adapter = createAgentApiHttpAdapter({
+    controller,
+    resolveSession: sessionRegistry.resolveSession,
+    closeSession: sessionRegistry.closeSession,
+  });
+  const privateServer = createAgentApiPrivateHttpServer({
+    adapter,
+    internalSecret,
+    maxBodyBytes: options.maxBodyBytes,
+  });
+
+  let state = 'idle';
+  let listenPromise;
+  let closePromise;
+
+  async function listen(input = {}) {
+    if (state === 'closed' || state === 'closing') {
+      throw new Error('Agent API service host is closed');
+    }
+    if (state !== 'idle') {
+      throw new Error('Agent API service host is already listening');
+    }
+    state = 'starting';
+    try {
+      listenPromise = privateServer.listen(input);
+      const address = await listenPromise;
+      if (state === 'closing' || state === 'closed') {
+        await privateServer.close();
+        throw new Error('Agent API service host is closed');
+      }
+      state = 'listening';
+      return address;
+    } catch (error) {
+      if (state === 'starting') state = 'idle';
+      throw error;
+    } finally {
+      listenPromise = undefined;
+    }
+  }
+
+  function close() {
+    if (closePromise !== undefined) return closePromise;
+    state = 'closing';
+    closePromise = (async () => {
+      let firstError;
+      if (listenPromise !== undefined) {
+        try {
+          await listenPromise;
+        } catch {
+          // The listen failure remains with its caller; cleanup continues here.
+        }
+      }
+      try {
+        await privateServer.close();
+      } catch (error) {
+        firstError = error;
+      }
+      try {
+        await sessionRegistry.close();
+      } catch (error) {
+        firstError ??= error;
+      }
+      state = 'closed';
+      if (firstError !== undefined) throw firstError;
+    })();
+    return closePromise;
+  }
+
+  return Object.freeze({ close, listen });
+}
+
+export {
+  MIN_SECRET_BYTES,
+  createAgentApiServiceHost,
+};

package/package.json

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