blun-king-cli 9.1.587 → 9.1.588

package/bin/agent-api-private-http-server.mjs

@@ -1,288 +0,0 @@
-import { createHash, timingSafeEqual } from 'node:crypto';
-import { createServer } from 'node:http';
-
-const DEFAULT_HOST = '127.0.0.1';
-const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
-const INTERNAL_SECRET_HEADER = 'x-blun-agent-secret';
-const INTERNAL_LIVE_PATH = '/internal/live';
-const PRINCIPAL_HEADER = 'x-blun-principal-id';
-const PRINCIPAL_PATTERN = /^[A-Za-z0-9._:-]{1,256}$/u;
-const LOOPBACK_HOSTS = new Set(['127.0.0.1', '::1']);
-
-class AgentApiPrivateHttpServerError extends Error {
-  constructor(code, message, status) {
-    super(message);
-    this.name = 'AgentApiPrivateHttpServerError';
-    this.code = code;
-    this.status = status;
-  }
-}
-
-function serverError(code, message, status) {
-  return new AgentApiPrivateHttpServerError(code, message, status);
-}
-
-function validateAdapter(adapter) {
-  if (adapter === null || typeof adapter !== 'object'
-    || typeof adapter.handleRequest !== 'function') {
-    throw new TypeError('adapter.handleRequest is required');
-  }
-  return adapter;
-}
-
-function validateSecret(secret) {
-  if (typeof secret !== 'string' || Buffer.byteLength(secret, 'utf8') < 32) {
-    throw new TypeError('internalSecret must contain at least 32 bytes');
-  }
-  return secret;
-}
-
-function validateMaxBodyBytes(value) {
-  if (!Number.isSafeInteger(value) || value < 1024) {
-    throw new TypeError('maxBodyBytes must be an integer of at least 1024');
-  }
-  return value;
-}
-
-function singleHeader(headers, name) {
-  const value = headers[name];
-  return typeof value === 'string' ? value : undefined;
-}
-
-function secretMatches(actual, expected) {
-  if (typeof actual !== 'string') return false;
-  const actualHash = createHash('sha256').update(actual, 'utf8').digest();
-  const expectedHash = createHash('sha256').update(expected, 'utf8').digest();
-  return timingSafeEqual(actualHash, expectedHash);
-}
-
-function requirePrincipal(headers) {
-  const principalId = singleHeader(headers, PRINCIPAL_HEADER);
-  if (principalId === undefined || !PRINCIPAL_PATTERN.test(principalId)) {
-    throw serverError(
-      'AGENT_API_UNAUTHENTICATED',
-      'Trusted Agent API principal is required.',
-      401,
-    );
-  }
-  return principalId;
-}
-
-function declaredLength(headers) {
-  const raw = singleHeader(headers, 'content-length');
-  if (raw === undefined) return undefined;
-  if (!/^\d+$/u.test(raw)) {
-    throw serverError('AGENT_API_INVALID_BODY', 'Request body length is invalid.', 400);
-  }
-  const value = Number(raw);
-  if (!Number.isSafeInteger(value)) {
-    throw serverError('AGENT_API_INVALID_BODY', 'Request body length is invalid.', 400);
-  }
-  return value;
-}
-
-function collectBody(request, maxBodyBytes) {
-  const length = declaredLength(request.headers);
-  if (length !== undefined && length > maxBodyBytes) {
-    request.resume();
-    throw serverError('AGENT_API_BODY_TOO_LARGE', 'Agent API request is too large.', 413);
-  }
-
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    let size = 0;
-    let settled = false;
-
-    request.on('data', (chunk) => {
-      if (settled) return;
-      size += chunk.length;
-      if (size > maxBodyBytes) {
-        settled = true;
-        chunks.length = 0;
-        request.resume();
-        reject(serverError(
-          'AGENT_API_BODY_TOO_LARGE',
-          'Agent API request is too large.',
-          413,
-        ));
-        return;
-      }
-      chunks.push(chunk);
-    });
-    request.on('end', () => {
-      if (settled) return;
-      settled = true;
-      resolve(Buffer.concat(chunks, size));
-    });
-    request.on('aborted', () => {
-      if (settled) return;
-      settled = true;
-      reject(serverError('AGENT_API_INVALID_BODY', 'Agent API request was aborted.', 400));
-    });
-    request.on('error', (error) => {
-      if (settled) return;
-      settled = true;
-      reject(error);
-    });
-  });
-}
-
-async function readJsonBody(request, maxBodyBytes) {
-  const buffer = await collectBody(request, maxBodyBytes);
-  if (buffer.length === 0) return {};
-  const contentType = singleHeader(request.headers, 'content-type');
-  if (contentType === undefined || !/^application\/json(?:\s*;|\s*$)/iu.test(contentType)) {
-    throw serverError(
-      'AGENT_API_UNSUPPORTED_MEDIA_TYPE',
-      'Agent API requests must use application/json.',
-      415,
-    );
-  }
-  try {
-    return JSON.parse(buffer.toString('utf8'));
-  } catch {
-    throw serverError('AGENT_API_INVALID_JSON', 'Request body is not valid JSON.', 400);
-  }
-}
-
-function publicError(error) {
-  if (error instanceof AgentApiPrivateHttpServerError) {
-    return {
-      status: error.status,
-      body: {
-        error: {
-          type: 'invalid_request_error',
-          code: error.code,
-          message: error.message,
-        },
-      },
-    };
-  }
-  return {
-    status: 500,
-    body: {
-      error: {
-        type: 'internal_error',
-        code: 'AGENT_API_INTERNAL',
-        message: 'Agent request failed.',
-      },
-    },
-  };
-}
-
-function writeJson(response, status, body, headers = {}) {
-  if (response.headersSent || response.destroyed) return;
-  response.writeHead(status, {
-    ...headers,
-    'cache-control': 'no-store',
-    'content-type': 'application/json',
-    'x-content-type-options': 'nosniff',
-  });
-  response.end(JSON.stringify(body));
-}
-
-function createAgentApiPrivateHttpServer(options = {}) {
-  const adapter = validateAdapter(options.adapter);
-  const internalSecret = validateSecret(options.internalSecret);
-  const maxBodyBytes = validateMaxBodyBytes(
-    options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES,
-  );
-
-  async function handle(request, response) {
-    try {
-      if (!secretMatches(singleHeader(request.headers, INTERNAL_SECRET_HEADER), internalSecret)) {
-        request.resume();
-        throw serverError('AGENT_API_UNAUTHENTICATED', 'Agent API authentication failed.', 401);
-      }
-      if (request.url === INTERNAL_LIVE_PATH) {
-        request.resume();
-        if (request.method !== 'GET') {
-          writeJson(response, 404, {
-            error: {
-              type: 'invalid_request_error',
-              code: 'AGENT_API_ROUTE_NOT_FOUND',
-              message: 'Agent API route not found.',
-            },
-          });
-          return;
-        }
-        writeJson(response, 200, {
-          status: 'ok',
-          service: 'king-agent-api',
-        });
-        return;
-      }
-      const principalId = requirePrincipal(request.headers);
-      const body = await readJsonBody(request, maxBodyBytes);
-      const result = await adapter.handleRequest({
-        method: request.method,
-        path: request.url,
-        principalId,
-        body,
-      });
-      if (result === null) {
-        writeJson(response, 404, {
-          error: {
-            type: 'invalid_request_error',
-            code: 'AGENT_API_ROUTE_NOT_FOUND',
-            message: 'Agent API route not found.',
-          },
-        });
-        return;
-      }
-      writeJson(response, result.status, result.body, result.headers);
-    } catch (error) {
-      const result = publicError(error);
-      writeJson(response, result.status, result.body);
-    }
-  }
-
-  const server = createServer((request, response) => {
-    void handle(request, response);
-  });
-  server.maxHeadersCount = 64;
-  server.headersTimeout = 10_000;
-  server.requestTimeout = 30_000;
-  server.keepAliveTimeout = 5_000;
-
-  function listen(input = {}) {
-    const host = input.host ?? DEFAULT_HOST;
-    const port = input.port ?? 0;
-    if (!LOOPBACK_HOSTS.has(host)) {
-      throw new TypeError('Agent API private server may listen on loopback only');
-    }
-    if (!Number.isInteger(port) || port < 0 || port > 65_535) {
-      throw new TypeError('port must be an integer from 0 through 65535');
-    }
-    return new Promise((resolve, reject) => {
-      const onError = (error) => reject(error);
-      server.once('error', onError);
-      server.listen({ host, port, exclusive: true }, () => {
-        server.off('error', onError);
-        resolve(server.address());
-      });
-    });
-  }
-
-  function close() {
-    if (!server.listening) return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      server.close((error) => {
-        if (error) reject(error);
-        else resolve();
-      });
-    });
-  }
-
-  return Object.freeze({ close, listen, server });
-}
-
-export {
-  AgentApiPrivateHttpServerError,
-  DEFAULT_HOST,
-  DEFAULT_MAX_BODY_BYTES,
-  INTERNAL_LIVE_PATH,
-  INTERNAL_SECRET_HEADER,
-  PRINCIPAL_HEADER,
-  createAgentApiPrivateHttpServer,
-};

package/bin/agent-api-runtime.mjs

@@ -1,252 +0,0 @@
-import { createHash } from 'node:crypto';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const { createAgentApiToolBroker } = require('./agent-api-tool-broker.cjs');
-
-const CLIENT_TOOL_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/u;
-const INTERNAL_TOOL_PREFIX = 'client__';
-const AGENT_API_INTERNAL_TOOLS = Object.freeze([
-  'Agent',
-  'TaskList',
-  'TaskOutput',
-  'TaskStop',
-]);
-
-class AgentApiRuntimeError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.name = 'AgentApiRuntimeError';
-    this.code = code;
-  }
-}
-
-function runtimeError(code, message) {
-  return new AgentApiRuntimeError(code, message);
-}
-
-function requireId(value, label) {
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw runtimeError('AGENT_API_INVALID_SCOPE', `${label} must be a non-empty string`);
-  }
-  return value.trim();
-}
-
-function cloneStructured(value, label) {
-  try {
-    return structuredClone(value);
-  } catch {
-    throw runtimeError(
-      'AGENT_API_INVALID_TOOL_DEFINITION',
-      `${label} must be structured-cloneable`,
-    );
-  }
-}
-
-function normalizeParameters(value, name) {
-  if (value === undefined) {
-    return { type: 'object', properties: {} };
-  }
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-    throw runtimeError(
-      'AGENT_API_INVALID_TOOL_DEFINITION',
-      `tool "${name}" parameters must be an object`,
-    );
-  }
-  return cloneStructured(value, `tool "${name}" parameters`);
-}
-
-function normalizeClientToolDefinitions(tools) {
-  if (!Array.isArray(tools)) {
-    throw runtimeError('AGENT_API_INVALID_TOOLS', 'tools must be an array');
-  }
-
-  const names = new Set();
-  return tools.map((tool, index) => {
-    if (tool === null || typeof tool !== 'object' || Array.isArray(tool)
-      || tool.type !== 'function'
-      || tool.function === null
-      || typeof tool.function !== 'object'
-      || Array.isArray(tool.function)) {
-      throw runtimeError(
-        'AGENT_API_INVALID_TOOL_DEFINITION',
-        `tools[${index}] must be an OpenAI function tool`,
-      );
-    }
-
-    const name = tool.function.name;
-    if (typeof name !== 'string' || !CLIENT_TOOL_NAME_PATTERN.test(name)) {
-      throw runtimeError(
-        'AGENT_API_INVALID_TOOL_DEFINITION',
-        `tools[${index}].function.name must match ${CLIENT_TOOL_NAME_PATTERN}`,
-      );
-    }
-    if (names.has(name)) {
-      throw runtimeError(
-        'AGENT_API_DUPLICATE_TOOL_NAME',
-        `tool name "${name}" is declared more than once`,
-      );
-    }
-    names.add(name);
-
-    const description = tool.function.description;
-    if (description !== undefined && typeof description !== 'string') {
-      throw runtimeError(
-        'AGENT_API_INVALID_TOOL_DEFINITION',
-        `tool "${name}" description must be a string`,
-      );
-    }
-
-    return Object.freeze({
-      name,
-      description: description ?? '',
-      parameters: normalizeParameters(tool.function.parameters, name),
-    });
-  });
-}
-
-function shortHash(value, length = 10) {
-  return createHash('sha256').update(value).digest('hex').slice(0, length);
-}
-
-function internalToolName(publicName, index) {
-  const ordinal = index.toString(36).padStart(2, '0');
-  const prefix = `${INTERNAL_TOOL_PREFIX}${ordinal}__`;
-  const suffix = `__${shortHash(publicName, 8)}`;
-  const available = 64 - prefix.length - suffix.length;
-  return `${prefix}${publicName.slice(0, available)}${suffix}`;
-}
-
-function validateSession(session) {
-  if (session === null || typeof session !== 'object') {
-    throw runtimeError('AGENT_API_INVALID_SESSION', 'session must be an SDK session');
-  }
-  const requiredMethods = [
-    'registerToolAndWait',
-    'unregisterToolAndWait',
-    'setAllowedTools',
-  ];
-  for (const method of requiredMethods) {
-    if (typeof session[method] !== 'function') {
-      throw runtimeError(
-        'AGENT_API_INVALID_SESSION',
-        `session.${method} must be a function`,
-      );
-    }
-  }
-  return requireId(session.id, 'session.id');
-}
-
-async function unregisterTools(session, names) {
-  let firstError;
-  for (const name of [...names].reverse()) {
-    try {
-      await session.unregisterToolAndWait(name);
-    } catch (error) {
-      firstError ??= error;
-    }
-  }
-  if (firstError !== undefined) throw firstError;
-}
-
-function createAgentApiRuntime(options = {}) {
-  const broker = options.broker ?? createAgentApiToolBroker(options.brokerOptions);
-
-  async function bindClientTools(input) {
-    if (input === null || typeof input !== 'object') {
-      throw runtimeError('AGENT_API_INVALID_REQUEST', 'binding input must be an object');
-    }
-
-    const sessionId = validateSession(input.session);
-    const requestId = requireId(input.requestId, 'requestId');
-    const tools = normalizeClientToolDefinitions(input.tools ?? []);
-    const mappings = tools.map((tool, index) => Object.freeze({
-      ...tool,
-      internalName: internalToolName(tool.name, index),
-    }));
-    const registeredNames = [];
-
-    broker.beginRequest({
-      sessionId,
-      requestId,
-      toolNames: mappings.map((tool) => tool.name),
-    });
-
-    try {
-      for (const tool of mappings) {
-        await input.session.registerToolAndWait(
-          tool.internalName,
-          tool.description,
-          tool.parameters,
-          (request) => broker.handleToolCall({
-            sessionId,
-            turnId: request.turnId,
-            toolCallId: request.toolCallId,
-            toolName: tool.name,
-            args: request.args,
-          }),
-        );
-        registeredNames.push(tool.internalName);
-      }
-
-      await input.session.setAllowedTools([
-        ...AGENT_API_INTERNAL_TOOLS,
-        ...registeredNames,
-      ]);
-    } catch (error) {
-      broker.abortRequest({
-        sessionId,
-        requestId,
-        reason: 'Agent API SDK binding failed',
-      });
-      try {
-        await unregisterTools(input.session, registeredNames);
-      } catch {
-        // Preserve the binding error; cleanup was best-effort and all handlers are fail-closed.
-      }
-      throw error;
-    }
-
-    let closed = false;
-    function ensureOpen() {
-      if (closed) {
-        throw runtimeError('AGENT_API_BINDING_CLOSED', 'Agent API SDK binding is closed');
-      }
-    }
-
-    return Object.freeze({
-      sessionId,
-      requestId,
-      nextToolCall() {
-        ensureOpen();
-        return broker.nextToolCall({ sessionId, requestId });
-      },
-      submitToolResult(result) {
-        ensureOpen();
-        return broker.submitToolResult({ sessionId, requestId, ...result });
-      },
-      async finish() {
-        ensureOpen();
-        broker.finishRequest({ sessionId, requestId });
-        closed = true;
-        await unregisterTools(input.session, registeredNames);
-      },
-      async abort(reason = 'Agent API request aborted') {
-        ensureOpen();
-        broker.abortRequest({ sessionId, requestId, reason });
-        closed = true;
-        await unregisterTools(input.session, registeredNames);
-      },
-    });
-  }
-
-  return Object.freeze({ bindClientTools });
-}
-
-export {
-  AGENT_API_INTERNAL_TOOLS,
-  AgentApiRuntimeError,
-  CLIENT_TOOL_NAME_PATTERN,
-  createAgentApiRuntime,
-  normalizeClientToolDefinitions,
-};