blun-king-cli 9.1.587 → 9.1.588

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

@@ -1,446 +0,0 @@
-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;
-
-class AgentApiHttpAdapterError extends Error {
-  constructor(code, message, status = 400) {
-    super(message);
-    this.name = 'AgentApiHttpAdapterError';
-    this.code = code;
-    this.status = status;
-  }
-}
-
-function adapterError(code, message, status = 400) {
-  return new AgentApiHttpAdapterError(code, message, status);
-}
-
-function requireTrustedId(value, label) {
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw adapterError('AGENT_API_UNAUTHENTICATED', `${label} is required`, 401);
-  }
-  return value.trim();
-}
-
-function requirePublicId(value, label) {
-  if (typeof value !== 'string' || !PUBLIC_ID_PATTERN.test(value)) {
-    throw adapterError(
-      'AGENT_API_INVALID_ID',
-      `${label} must match ${PUBLIC_ID_PATTERN}`,
-    );
-  }
-  return value;
-}
-
-function requireBody(value) {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-    throw adapterError('AGENT_API_INVALID_BODY', 'request body must be a JSON object');
-  }
-  return value;
-}
-
-function requireKing(value) {
-  if (value !== PUBLIC_MODEL_ID) {
-    throw adapterError('AGENT_API_INVALID_MODEL', 'model must be king');
-  }
-}
-
-function normalizePrompt(value) {
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw adapterError('AGENT_API_INVALID_INPUT', 'input must be a non-empty string');
-  }
-  return value;
-}
-
-function normalizeTools(value) {
-  if (value === undefined) return [];
-  if (!Array.isArray(value)) {
-    throw adapterError('AGENT_API_INVALID_TOOLS', 'tools must be an array');
-  }
-  return value;
-}
-
-function decodeRequestId(value) {
-  let decoded;
-  try {
-    decoded = decodeURIComponent(value);
-  } catch {
-    throw adapterError('AGENT_API_INVALID_ID', 'request ID is not valid URL encoding');
-  }
-  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;
-  }
-
-  const tail = path.slice(AGENT_TURNS_PATH.length + 1);
-  const toolSuffix = '/tool-results';
-  if (method === 'POST' && tail.endsWith(toolSuffix)) {
-    return {
-      kind: 'continue',
-      requestId: decodeRequestId(tail.slice(0, -toolSuffix.length)),
-    };
-  }
-  if (method === 'DELETE' && !tail.includes('/')) {
-    return { kind: 'cancel', requestId: decodeRequestId(tail) };
-  }
-  return { kind: 'unknown' };
-}
-
-function jsonResponse(status, body) {
-  return {
-    status,
-    headers: { 'content-type': 'application/json' },
-    body,
-  };
-}
-
-function publicCompletion(response) {
-  if (response === null || typeof response !== 'object' || Array.isArray(response)) {
-    throw adapterError('AGENT_API_INVALID_CONTROLLER_RESPONSE', 'Agent response is invalid', 502);
-  }
-  return { ...response, model: PUBLIC_MODEL_ID };
-}
-
-function publicErrorResponse(error) {
-  if (error instanceof AgentApiHttpAdapterError) {
-    return jsonResponse(error.status, {
-      error: {
-        type: 'invalid_request_error',
-        code: error.code,
-        message: error.message,
-      },
-    });
-  }
-
-  const code = typeof error?.code === 'string' ? error.code : '';
-  if (code === 'AGENT_API_TURN_SCOPE_MISMATCH') {
-    return jsonResponse(403, {
-      error: {
-        type: 'permission_error',
-        code,
-        message: 'Agent turn belongs to a different request.',
-      },
-    });
-  }
-  if (code === 'AGENT_API_SESSION_BUSY' || code === 'AGENT_API_TURN_NOT_ACTIVE') {
-    return jsonResponse(409, {
-      error: {
-        type: 'conflict_error',
-        code,
-        message: 'Agent session is not ready for this operation.',
-      },
-    });
-  }
-  if (code === 'AGENT_API_SESSION_NOT_FOUND') {
-    return jsonResponse(404, {
-      error: {
-        type: 'invalid_request_error',
-        code,
-        message: 'Agent session was not found.',
-      },
-    });
-  }
-  if (code === 'AGENT_API_SESSION_LIMIT' || code === 'AGENT_API_PRINCIPAL_LIMIT') {
-    return jsonResponse(429, {
-      error: {
-        type: 'rate_limit_error',
-        code,
-        message: 'Agent session limit reached.',
-      },
-    });
-  }
-  if (code.startsWith('AGENT_API_INVALID_')) {
-    return jsonResponse(400, {
-      error: {
-        type: 'invalid_request_error',
-        code,
-        message: 'Agent request is invalid.',
-      },
-    });
-  }
-  if (code === 'AGENT_API_TURN_FAILED') {
-    return jsonResponse(502, {
-      error: {
-        type: 'upstream_error',
-        code,
-        message: 'Agent turn failed.',
-      },
-    });
-  }
-  return jsonResponse(500, {
-    error: {
-      type: 'internal_error',
-      code: 'AGENT_API_INTERNAL',
-      message: 'Agent request failed.',
-    },
-  });
-}
-
-function scopeKey(sessionId, requestId) {
-  return `${sessionId}\0${requestId}`;
-}
-
-function responseNeedsToolResult(response) {
-  return response?.choices?.[0]?.finish_reason === 'tool_calls';
-}
-
-function validateController(controller) {
-  if (controller === null || typeof controller !== 'object') {
-    throw new TypeError('controller is required');
-  }
-  for (const method of ['startTurn', 'continueTurn', 'cancelTurn']) {
-    if (typeof controller[method] !== 'function') {
-      throw new TypeError(`controller.${method} must be a function`);
-    }
-  }
-  return controller;
-}
-
-function createAgentApiHttpAdapter(options = {}) {
-  const controller = validateController(options.controller);
-  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');
-  }
-  if (options.touchSession !== undefined && typeof options.touchSession !== 'function') {
-    throw new TypeError('touchSession 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 isSessionActive(input) {
-    return input !== null
-      && typeof input === 'object'
-      && hasActiveOwner(input.principalId, input.sessionId);
-  }
-
-  function touchSession(principalId, sessionId) {
-    try {
-      options.touchSession?.({ principalId, sessionId });
-    } catch {
-      // Activity bookkeeping must not replace the customer response.
-    }
-  }
-
-  function requireOwner(principalId, sessionId, requestId) {
-    const key = scopeKey(sessionId, requestId);
-    const scopeOwners = owners.get(key);
-    if (scopeOwners === undefined) {
-      throw adapterError(
-        'AGENT_API_TURN_NOT_ACTIVE',
-        'Agent turn is not active.',
-        409,
-      );
-    }
-    const internalSessionId = scopeOwners.get(principalId);
-    if (internalSessionId === undefined) {
-      throw adapterError(
-        'AGENT_API_FORBIDDEN',
-        'Agent turn belongs to a different account.',
-        403,
-      );
-    }
-    return { internalSessionId, key };
-  }
-
-  function trackScope(key, principalId, internalSessionId, response) {
-    if (responseNeedsToolResult(response)) {
-      const scopeOwners = owners.get(key) ?? new Map();
-      scopeOwners.set(principalId, internalSessionId);
-      owners.set(key, scopeOwners);
-      return;
-    }
-    const scopeOwners = owners.get(key);
-    scopeOwners?.delete(principalId);
-    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);
-    if (body.stream === true) {
-      throw adapterError(
-        'AGENT_API_STREAMING_UNSUPPORTED',
-        'streaming is not available on Agent turns yet',
-      );
-    }
-    const sessionId = requirePublicId(body.session_id, 'session_id');
-    const requestId = requirePublicId(body.request_id, 'request_id');
-    const session = await options.resolveSession({
-      principalId,
-      sessionId,
-      create: true,
-    });
-    if (typeof session?.id !== 'string' || session.id.trim().length === 0) {
-      throw adapterError(
-        'AGENT_API_SESSION_SCOPE_MISMATCH',
-        'resolved session does not have an isolated session ID',
-        403,
-      );
-    }
-    const internalSessionId = session.id.trim();
-    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,
-      }));
-      touchSession(principalId, sessionId);
-      trackScope(key, principalId, internalSessionId, response);
-      return jsonResponse(200, response);
-    } catch (error) {
-      touchSession(principalId, sessionId);
-      trackScope(key, principalId, internalSessionId, null);
-      throw error;
-    }
-  }
-
-  async function handleContinue(input, principalId, requestId) {
-    const body = requireBody(input.body);
-    const sessionId = requirePublicId(body.session_id, 'session_id');
-    const owner = requireOwner(principalId, sessionId, requestId);
-    try {
-      const response = publicCompletion(await controller.continueTurn({
-        sessionId: owner.internalSessionId,
-        requestId,
-        toolResults: body.tool_results,
-      }));
-      touchSession(principalId, sessionId);
-      trackScope(owner.key, principalId, owner.internalSessionId, response);
-      return jsonResponse(200, response);
-    } catch (error) {
-      touchSession(principalId, sessionId);
-      trackScope(owner.key, principalId, owner.internalSessionId, null);
-      throw error;
-    }
-  }
-
-  async function handleCancel(input, principalId, requestId) {
-    const body = requireBody(input.body ?? {});
-    const sessionId = requirePublicId(body.session_id, 'session_id');
-    const owner = requireOwner(principalId, sessionId, requestId);
-    await controller.cancelTurn({
-      sessionId: owner.internalSessionId,
-      requestId,
-      reason: typeof body.reason === 'string' ? body.reason : undefined,
-    });
-    touchSession(principalId, sessionId);
-    trackScope(owner.key, principalId, owner.internalSessionId, null);
-    return jsonResponse(200, {
-      id: `agent-${requestId}`,
-      object: 'agent.turn.cancelled',
-      model: PUBLIC_MODEL_ID,
-      cancelled: true,
-    });
-  }
-
-  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();
-    let route;
-    try {
-      route = routeFor(method, input.path);
-      if (route === null) return null;
-      if (route.kind === 'unknown') {
-        return jsonResponse(404, {
-          error: {
-            type: 'invalid_request_error',
-            code: 'AGENT_API_ROUTE_NOT_FOUND',
-            message: 'Agent API route not found.',
-          },
-        });
-      }
-      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);
-      }
-      return await handleCancel(input, principalId, route.requestId);
-    } catch (error) {
-      return publicErrorResponse(error);
-    }
-  }
-
-  return Object.freeze({ handleRequest, isSessionActive });
-}
-
-export {
-  AGENT_SESSIONS_PATH,
-  AGENT_TURNS_PATH,
-  AgentApiHttpAdapterError,
-  PUBLIC_MODEL_ID,
-  createAgentApiHttpAdapter,
-};