protocol.c File Reference

Go to the source code of this file.

Functions
yyjson_mut_doc *	mcp_error (yyjson_val *id, int code, const char *message)
void	mcp_jobs_reap (mcp_server_t *s, bool all)
yyjson_mut_doc *	mcp_dispatch (mcp_server_t *s, yyjson_doc *message, void *connection, const char *session_id, bool *pending)

Function Documentation

mcp_dispatch()

yyjson_mut_doc * mcp_dispatch	(	mcp_server_t *	s,
		yyjson_doc *	message,
		void *	connection,
		const char *	session_id,
		bool *	pending )

Definition at line 222 of file mcp-server/protocol.c.

                                            {
  ASCII_OTEL_SCOPE(MCP_REQUEST);
  ASCII_OTEL_ATTR_STRING("rpc.system", "jsonrpc");
  ASCII_OTEL_ATTR_STRING("mcp.transport", s->policy.hosted ? "http" : "stdio");
  stats_counter_add(stats_runtime_scope(), STATS_COUNTER_MCP_REQUESTS, 1);
  *pending = false;
  yyjson_val *root = yyjson_doc_get_root(message), *id = mcp_get(root, "id"), *method = mcp_get(root, "method"),
             *version = mcp_get(root, "jsonrpc");
  if (!yyjson_is_obj(root) || !yyjson_is_str(version) || strcmp(yyjson_get_str(version), "2.0") ||
      !yyjson_is_str(method) || strlen(yyjson_get_str(method)) != yyjson_get_len(method) ||
      (id && !yyjson_is_str(id) && !yyjson_is_int(id)))
    return mcp_error(id, -32600, "Invalid JSON-RPC request");
  const char *name = yyjson_get_str(method);
  static const char *const methods[] = {
      "initialize", "ping", "tools/list", "tools/call", "notifications/initialized", "notifications/cancelled"};
  const char *method_name = "unknown";
  for (size_t i = 0; i < sizeof(methods) / sizeof(methods[0]); i++)
    if (!strcmp(name, methods[i]))
      method_name = methods[i];
  ASCII_OTEL_ATTR_STRING("rpc.method", method_name);
  yyjson_val *params = mcp_get(root, "params");
  if (params && !yyjson_is_obj(params))
    return id ? mcp_error(id, -32602, "params must be an object") : NULL;
  if (!id) {
    if (!strcmp(name, "notifications/initialized"))
      s->initialized = true;
    if (!strcmp(name, "notifications/cancelled")) {
      yyjson_val *cancel = mcp_get(params, "requestId");
      for (unsigned i = 0; i < s->policy.max_jobs; ++i)
        if (s->jobs[i].renderer_job.started &&
            (!s->policy.hosted || (session_id && *session_id && !strcmp(s->jobs[i].session_id, session_id)) ||
             ((!session_id || !*session_id) && s->jobs[i].connection == connection)) &&
            same_id(cancel, mcp_get(yyjson_doc_get_root(s->jobs[i].message), "id")))
          http_renderer_job_cancel(&s->jobs[i].renderer_job);
    }
    return NULL;
  }
  yyjson_mut_doc *d = envelope(id);
  yyjson_mut_val *result = yyjson_mut_obj(d);
  yyjson_mut_obj_add_val(d, yyjson_mut_doc_get_root(d), "result", result);
  if (!strcmp(name, "initialize")) {
    yyjson_val *requested = mcp_get(params, "protocolVersion");
    const char *v = yyjson_get_str(requested);
    if (!v || (strcmp(v, "2025-11-25") && strcmp(v, "2025-06-18") && strcmp(v, "2025-03-26")))
      v = "2025-11-25";
    yyjson_mut_obj_add_strcpy(d, result, "protocolVersion", v);
    yyjson_mut_val *caps = yyjson_mut_obj(d), *info = yyjson_mut_obj(d);
    yyjson_mut_obj_add_val(d, caps, "tools", yyjson_mut_obj(d));
    yyjson_mut_obj_add_val(d, result, "capabilities", caps);
    yyjson_mut_obj_add_str(d, info, "name", "ascii-chat");
    yyjson_mut_obj_add_str(d, info, "version", ASCII_CHAT_VERSION_FULL);
    yyjson_mut_obj_add_val(d, result, "serverInfo", info);
    const char *instructions =
        s->policy.restricted && s->policy.hosted
            ? "Render uploaded bytes or HTTP(S) media URLs as ASCII art. The hosted server cannot access your webcam "
              "or "
              "local filesystem. Rendered files are returned as temporary download links with UTC expiration "
              "timestamps; "
              "links expire after 30 minutes. Use output_format to select the file format, snapshot-delay to set clip "
              "duration, and options.audio=true to include source audio."
            : "Render media as ASCII art. Uploaded bytes must be base64 encoded by the client. snapshot-delay measures "
              "capture duration after the first rendered frame; use seek for media timestamps. output_path saves ASCII "
              "art "
              "as an image/video and never replaces an existing file.";
    yyjson_mut_obj_add_str(d, result, "instructions", instructions);
    return d;
  }
  if (!strcmp(name, "ping"))
    return d;
  if (!strcmp(name, "tools/list")) {
    yyjson_mut_obj_add_val(d, result, "tools", mcp_tools_schema(d, &s->policy));
    return d;
  }
  yyjson_mut_doc_free(d);
  if (strcmp(name, "tools/call"))
    return mcp_error(id, -32601, "Method not found");
  const char *tool = yyjson_get_str(mcp_get(params, "name"));
  if (tool && yyjson_get_len(mcp_get(params, "name")) == sizeof("device_list") - 1 && !strcmp(tool, "device_list")) {
    if (s->policy.restricted)
      return mcp_error(id, -32602, "Unknown tool");
    ASCII_OTEL_ATTR_STRING("mcp.tool", "device_list");
    return device_list_result(id, mcp_get(params, "arguments"));
  }
  const char *names[] = {"render_file", "render_url", "render_webcam", "render_visualization"};
  int kind = -1;
  for (int i = 0; i < 4; ++i)
    if (tool && strlen(tool) == yyjson_get_len(mcp_get(params, "name")) && !strcmp(tool, names[i]))
      kind = i;
  if (kind < 0 || (s->policy.restricted && kind == MCP_WEBCAM))
    return mcp_error(id, -32602, "Unknown tool");
  mcp_jobs_reap(s, false);
  mcp_job_t *j = NULL;
  for (unsigned i = 0; i < s->policy.max_jobs; ++i)
    if (!s->jobs[i].renderer_job.started) {
      j = &s->jobs[i];
      break;
    }
  if (!j) {
    char message[128];
    safe_snprintf(message, sizeof(message), "Server busy; at most %u render%s may run concurrently", s->policy.max_jobs,
                  s->policy.max_jobs == 1 ? "" : "s");
    return mcp_error(id, -32000, message);
  }
  yyjson_val *arguments = mcp_get(params, "arguments");
  yyjson_doc *empty = NULL;
  if (!arguments) {
    empty = yyjson_read("{}", 2, 0);
    arguments = yyjson_doc_get_root(empty);
  }
  asciichat_error_t err = mcp_request_parse(&s->policy, (mcp_tool_t)kind, arguments, &j->request);
  if (empty)
    yyjson_doc_free(empty);
  if (err != ASCIICHAT_OK) {
    stats_counter_add(stats_runtime_scope(), STATS_COUNTER_MCP_REJECTED, 1);
    ASCII_OTEL_ATTR_STRING("error.type", "invalid_arguments");
    asciichat_error_context_t ctx;
    http_renderer_process_result_t fail = {0};
    SAFE_STRNCPY(fail.error, HAS_ERRNO(&ctx) ? ctx.context_message : "Invalid render request", sizeof(fail.error));
    mcp_request_destroy(&j->request);
    return tool_result(id, &fail);
  }
  // Copy before returning to the transport, which owns and frees the input document.
  size_t len;
  char *copy = yyjson_write(message, 0, &len);
  j->message = yyjson_read(copy, len, 0);
  free(copy);
  j->tool = (mcp_tool_t)kind;
  j->telemetry_parent = ascii_otel_context();
  j->server = s;
  j->connection = connection;
  if (session_id)
    SAFE_STRNCPY(j->session_id, session_id, sizeof(j->session_id));
  if (http_renderer_job_start(&j->renderer_job, "mcp-render", run_job, j) != ASCIICHAT_OK) {
    mcp_request_destroy(&j->request);
    yyjson_doc_free(j->message);
    memset(j, 0, sizeof(*j));
    return mcp_error(id, -32603, "Cannot create render worker");
  }
  *pending = true;
  return NULL;
}

References ASCII_OTEL_ATTR_STRING, ascii_otel_context(), ASCII_OTEL_SCOPE, ASCIICHAT_OK, mcp_job::connection, asciichat_error_context_t::context_message, http_renderer_process_result_t::error, HAS_ERRNO, mcp_policy_t::hosted, http_renderer_job_cancel(), http_renderer_job_start(), mcp_server::initialized, mcp_server::jobs, mcp_policy_t::max_jobs, mcp_error(), mcp_jobs_reap(), mcp_request_destroy(), mcp_request_parse(), mcp_tools_schema(), MCP_WEBCAM, mcp_job::message, mcp_server::policy, mcp_job::renderer_job, mcp_job::request, mcp_policy_t::restricted, safe_snprintf(), SAFE_STRNCPY, mcp_job::server, mcp_job::session_id, session_id, http_renderer_job::started, stats_counter_add(), STATS_COUNTER_MCP_REJECTED, STATS_COUNTER_MCP_REQUESTS, stats_runtime_scope(), mcp_job::telemetry_parent, and mcp_job::tool.

Referenced by mcp_stdio_run().

mcp_error()

yyjson_mut_doc * mcp_error	(	yyjson_val *	id,
		int	code,
		const char *	message )

Definition at line 17 of file mcp-server/protocol.c.

                                                                         {
  ASCII_OTEL_SCOPE(MCP_PROTOCOL_ERROR);
  ASCII_OTEL_ATTR_INT("rpc.jsonrpc.error_code", code);
  stats_counter_add(stats_runtime_scope(), STATS_COUNTER_MCP_REJECTED, 1);
  ascii_otel_error("MCP protocol request rejected");
  yyjson_mut_doc *d = envelope(id);
  yyjson_mut_val *e = yyjson_mut_obj(d);
  yyjson_mut_obj_add_int(d, e, "code", code);
  yyjson_mut_obj_add_strcpy(d, e, "message", message);
  yyjson_mut_obj_add_val(d, yyjson_mut_doc_get_root(d), "error", e);
  return d;
}

References ASCII_OTEL_ATTR_INT, ascii_otel_error(), ASCII_OTEL_SCOPE, stats_counter_add(), STATS_COUNTER_MCP_REJECTED, and stats_runtime_scope().

Referenced by mcp_dispatch(), and mcp_stdio_run().

mcp_jobs_reap()

void mcp_jobs_reap	(	mcp_server_t *	s,
		bool	all )

Definition at line 203 of file mcp-server/protocol.c.

                                              {
  for (unsigned i = 0; i < s->policy.max_jobs; ++i) {
    mcp_job_t *j = &s->jobs[i];
    if (!j->renderer_job.started ||
        (!all && (!http_renderer_job_is_done(&j->renderer_job) || (s->policy.hosted && j->connection))))
      continue;
    http_renderer_job_join(&j->renderer_job);
    yyjson_doc_free(j->message);
    if (j->response)
      yyjson_mut_doc_free(j->response);
    memset(j, 0, sizeof(*j));
  }
}

References mcp_job::connection, mcp_policy_t::hosted, http_renderer_job_is_done(), http_renderer_job_join(), mcp_server::jobs, mcp_policy_t::max_jobs, mcp_job::message, mcp_server::policy, mcp_job::renderer_job, mcp_job::response, and http_renderer_job::started.

Referenced by mcp_dispatch(), mcp_http_run(), mcp_server_main(), and mcp_stdio_run().