request.c File Reference

Go to the source code of this file.

Macros
#define	MCP_SERVER_REQUEST_BUF_BUFFER_SIZE   4097
#define	MCP_SERVER_REQUEST_INDEX_BUFFER_SIZE   16
#define	MCP_SERVER_REQUEST_VALUE_BUFFER_SIZE   64
#define	MCP_SERVER_REQUEST_B_BUFFER_SIZE   16
#define	MCP_REQUEST_ARGV_CAPACITY   256
#define	MCP_REQUEST_RESERVED_ARGS   6

Functions
yyjson_mut_val *	mcp_tools_schema (yyjson_mut_doc *d, const mcp_policy_t *p)
asciichat_error_t	mcp_request_parse (const mcp_policy_t *p, mcp_tool_t tool, yyjson_val *a, http_renderer_process_request_t *r)
void	mcp_request_destroy (http_renderer_process_request_t *r)

Macro Definition Documentation

MCP_REQUEST_ARGV_CAPACITY

#define MCP_REQUEST_ARGV_CAPACITY   256

Definition at line 9 of file request.c.

Referenced by mcp_request_parse().

MCP_REQUEST_RESERVED_ARGS

#define MCP_REQUEST_RESERVED_ARGS   6

Definition at line 10 of file request.c.

MCP_SERVER_REQUEST_B_BUFFER_SIZE

#define MCP_SERVER_REQUEST_B_BUFFER_SIZE   16

Definition at line 6 of file request.c.

Referenced by mcp_request_parse().

MCP_SERVER_REQUEST_BUF_BUFFER_SIZE

#define MCP_SERVER_REQUEST_BUF_BUFFER_SIZE   4097

Definition at line 3 of file request.c.

Referenced by mcp_request_parse().

MCP_SERVER_REQUEST_INDEX_BUFFER_SIZE

#define MCP_SERVER_REQUEST_INDEX_BUFFER_SIZE   16

Definition at line 4 of file request.c.

Referenced by mcp_request_parse().

MCP_SERVER_REQUEST_VALUE_BUFFER_SIZE

#define MCP_SERVER_REQUEST_VALUE_BUFFER_SIZE   64

Definition at line 5 of file request.c.

Referenced by mcp_request_parse().

Function Documentation

mcp_request_destroy()

void mcp_request_destroy

(

http_renderer_process_request_t *

r

)

Definition at line 678 of file request.c.

                                                             {
  for (size_t i = 0; i < r->argc; ++i)
    SAFE_FREE(r->argv[i]);
  SAFE_FREE(r->argv);
  if (r->upload_dir[0]) {
    asciichat_error_t e = platform_rmdir_recursive(r->upload_dir);
    (void)e;
  }
  if (r->stage_dir[0]) {
    asciichat_error_t e = platform_rmdir_recursive(r->stage_dir);
    (void)e;
  }
  memset(r, 0, sizeof(*r));
}

References http_renderer_process_request_t::argc, http_renderer_process_request_t::argv, SAFE_FREE, http_renderer_process_request_t::stage_dir, and http_renderer_process_request_t::upload_dir.

Referenced by mcp_dispatch().

mcp_request_parse()

asciichat_error_t mcp_request_parse	(	const mcp_policy_t *	p,
		mcp_tool_t	tool,
		yyjson_val *	a,
		http_renderer_process_request_t *	r )

Definition at line 416 of file request.c.

                                                                        {
  memset(r, 0, sizeof(*r));
  r->output_type = HTTP_RENDER_OUTPUT_TEXT;
  r->options.width = 100;
  r->options.height = 40;
  r->options.color_mode = TERM_COLOR_NONE;
  r->timeout_ms = 45000;
  r->argv = SAFE_CALLOC(MCP_REQUEST_ARGV_CAPACITY, sizeof(char *), char **);
  static const char *const fields[] = {"path",         "data_base64",   "mime_type",     "url",         "video_device",
                                       "audio",        "visualization", "options",       "output_path", "timeout_ms",
                                       "audio_device", "volume",        "output_format", "output",      NULL};
  asciichat_error_t err = check_fields(a, fields);
  if (err)
    return err;
  const char *source_fields[] = {"path",  "data_base64",   "mime_type",    "url",   "video_device",
                                 "audio", "visualization", "audio_device", "volume"};
  for (size_t i = 0; i < 9; ++i) {
    bool allowed = tool == MCP_FILE ? i < 3 : tool == MCP_URL ? i == 3 : tool == MCP_WEBCAM ? i == 4 || i >= 7 : i >= 5;
    if (!allowed && mcp_get(a, source_fields[i]))
      return SET_ERRNO(ERROR_INVALID_PARAM, "Argument %s is not valid for this tool", source_fields[i]);
  }
  if (p->restricted && (tool == MCP_WEBCAM || mcp_get(a, "path") || mcp_get(a, "output_path") ||
                        mcp_get(a, "audio_device") || mcp_get(a, "volume")))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Local capability is unavailable in server mode");
  yyjson_val *timeout = mcp_get(a, "timeout_ms");
  if (timeout) {
    if (!yyjson_is_int(timeout) || yyjson_get_sint(timeout) < 1000 || yyjson_get_sint(timeout) > 60000)
      return SET_ERRNO(ERROR_INVALID_PARAM, "timeout_ms must be 1000–60000");
    r->timeout_ms = (unsigned)yyjson_get_uint(timeout);
  }
  char exe[PLATFORM_MAX_PATH_LENGTH];
  if (!platform_get_executable_path(exe, sizeof(exe)))
    return SET_ERRNO(ERROR_FILE_OPERATION, "Cannot locate renderer executable");
  yyjson_val *opts = mcp_get(a, "options");
  if (opts && !yyjson_is_obj(opts))
    return SET_ERRNO(ERROR_INVALID_PARAM, "options must be an object");
  yyjson_val *format_value = mcp_get(a, "output_format"), *output_value = mcp_get(a, "output_path"),
             *output_mode = mcp_get(a, "output");
  if (output_mode && (!yyjson_is_str(output_mode) ||
                      (strcmp(yyjson_get_str(output_mode), "text") && strcmp(yyjson_get_str(output_mode), "files"))))
    return SET_ERRNO(ERROR_INVALID_PARAM, "output must be text or files");
  if (output_mode && !strcmp(yyjson_get_str(output_mode), "text") && output_value)
    return SET_ERRNO(ERROR_INVALID_PARAM, "output=text cannot be combined with output_path");
  if (output_mode && !strcmp(yyjson_get_str(output_mode), "files"))
    r->output_type = HTTP_RENDER_OUTPUT_FILE;
  const char *output_name = yyjson_is_str(output_value) ? yyjson_get_str(output_value) : "";
  const char *output_ext = strrchr(output_name, '.');
  bool gif_requested = yyjson_is_str(format_value) && !strcmp(yyjson_get_str(format_value), "gif");
  bool gif_path = output_ext && !strcmp(output_ext, ".gif");
  bool gif_output = gif_requested || gif_path;
  bool media_tool = tool == MCP_URL || tool == MCP_FILE;
  bool media_source = mcp_get(a, "url") || mcp_get(a, "path") || mcp_get(a, "data_base64");
  bool snapshot_requested = mcp_get(opts, "snapshot") || mcp_get(opts, "snapshot-delay");
  bool gif_auto = gif_output && media_tool && media_source && !snapshot_requested;
  arg(r, exe);
  arg(r, "--log-level=error");
  arg(r, "--no-check-update");
  arg(r, "mirror");
  option(r, "width", "100");
  option(r, "height", "40");
  option(r, "color-mode", "none");
  option(r, "strip-ansi", "true");
  option(r, "snapshot", gif_auto ? "false" : "true");
  if (!gif_auto && !yyjson_is_false(mcp_get(opts, "snapshot")))
    option(r, "snapshot-delay", "0");
  option(r, "splash-screen", "false");
  option(r, "no-audio-playback", "true");
  option(r, "audio", "false");
  size_t i, max;
  yyjson_val *k, *v;
  if (opts)
    yyjson_obj_foreach(opts, i, max, k, v) {
      const char *name = yyjson_get_str(k);
      const registry_entry_t *e = exposed(p, name);
      if (strlen(name) != yyjson_get_len(k) || !e)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Unsupported option: %s", name);
      char buf[MCP_SERVER_REQUEST_BUF_BUFFER_SIZE];
      bool omitted = false;
      err = options_json_parse_value(name, v, buf, sizeof(buf), &omitted);
      if (err)
        return err;
      if (omitted)
        continue;
      double n = yyjson_get_num(v);
      if ((!strcmp(name, "width") && (n < e->metadata.numeric_range.min || n > 512)) ||
          (!strcmp(name, "height") && (n < e->metadata.numeric_range.min || n > 256)) ||
          (!strcmp(name, "snapshot-delay") && (n < 0 || n > 30)) || (!strcmp(name, "fps") && (n < 0 || n > 144)))
        return SET_ERRNO(ERROR_INVALID_PARAM, "Option %s is out of bounds", name);
      err = option(r, name, buf);
      if (err)
        return err;
      if (!strcmp(name, "width"))
        r->options.width = (int)n;
      else if (!strcmp(name, "height"))
        r->options.height = (int)n;
      else if (!strcmp(name, "color-mode")) {
        if (!strcmp(buf, "16"))
          r->options.color_mode = TERM_COLOR_16;
        else if (!strcmp(buf, "256"))
          r->options.color_mode = TERM_COLOR_256;
        else if (!strcmp(buf, "truecolor") || !strcmp(buf, "24bit"))
          r->options.color_mode = TERM_COLOR_TRUECOLOR;
        else
          r->options.color_mode = TERM_COLOR_NONE;
      } else if (!strcmp(name, "palette"))
        SAFE_STRNCPY(r->options.palette, buf, sizeof(r->options.palette));
      else if (!strcmp(name, "palette-chars"))
        SAFE_STRNCPY(r->options.palette_chars, buf, sizeof(r->options.palette_chars));
    }
  bool synthetic = enabled(opts, "test-pattern"), test_audio = enabled(opts, "test-audio");
  yyjson_val *audio_device = mcp_get(a, "audio_device"), *volume = mcp_get(a, "volume");
  if (audio_device) {
    if (!yyjson_is_int(audio_device) || yyjson_get_sint(audio_device) < -1 || yyjson_get_sint(audio_device) > INT_MAX)
      return SET_ERRNO(ERROR_INVALID_PARAM, "audio_device must be -1 or a nonnegative device index");
    char index[MCP_SERVER_REQUEST_INDEX_BUFFER_SIZE];
    SAFE_SNPRINTF(index, sizeof(index), "%d", (int)yyjson_get_sint(audio_device));
    err = option(r, "microphone-index", index);
    if (err)
      return err;
  }
  if (volume) {
    if (!yyjson_is_num(volume) || yyjson_get_num(volume) < 0 || yyjson_get_num(volume) > 1)
      return SET_ERRNO(ERROR_INVALID_PARAM, "volume must be a number from 0 to 1");
    char value[MCP_SERVER_REQUEST_VALUE_BUFFER_SIZE];
    bool omitted = false;
    err = options_json_parse_value("microphone-volume", volume, value, sizeof(value), &omitted);
    if (err)
      return err;
    if (mcp_get(opts, "microphone-volume") || mcp_get(opts, "ivolume"))
      return SET_ERRNO(ERROR_INVALID_PARAM, "volume conflicts with options.microphone-volume/ivolume");
    err = option(r, "microphone-volume", value);
    if (err)
      return err;
  }
  if (tool == MCP_FILE) {
    if (synthetic || test_audio) {
      if (mcp_get(a, "path") || mcp_get(a, "data_base64"))
        return SET_ERRNO(ERROR_INVALID_PARAM, "Synthetic source conflicts with media");
      if (!synthetic) {
        option(r, "waveform", "true");
        option(r, "audio", "true");
      }
    } else {
      err = source_file(p, a, r);
      if (err)
        return err;
    }
  } else if (tool == MCP_URL) {
    if (synthetic)
      return SET_ERRNO(ERROR_INVALID_PARAM, "test-pattern conflicts with URL");
    err = source_url(p, mcp_get(a, "url"), r);
    if (err)
      return err;
  } else if (tool == MCP_WEBCAM) {
    r->capture_webcam = !synthetic;
    bool record_audio =
        audio_device || volume || enabled(opts, "audio") ||
        (mcp_get(a, "output_path") && yyjson_get_num(mcp_get(opts, "snapshot-delay")) > 0 && !mcp_get(opts, "audio"));
    if (record_audio && mcp_get(opts, "audio") && !enabled(opts, "audio"))
      return SET_ERRNO(ERROR_INVALID_PARAM, "Microphone selection conflicts with options.audio=false");
    if (record_audio && !test_audio) {
      option(r, "audio", "true");
      option(r, "audio-source", "mic");
      option(r, "audio-capture-source", "mic");
    }
    yyjson_val *dev = mcp_get(a, "video_device");
    if (dev) {
      if (!yyjson_is_int(dev) || yyjson_get_sint(dev) < 0 || yyjson_get_sint(dev) > 10)
        return SET_ERRNO(ERROR_INVALID_PARAM, "video_device must be 0–10");
      char b[MCP_SERVER_REQUEST_B_BUFFER_SIZE];
      SAFE_SNPRINTF(b, sizeof(b), "%d", (int)yyjson_get_sint(dev));
      option(r, "webcam-index", b);
    }
  } else {
    if (synthetic)
      return SET_ERRNO(ERROR_INVALID_PARAM, "test-pattern conflicts with audio visualization");
    yyjson_val *visual = mcp_get(a, "visualization");
    if (!yyjson_is_str(visual) || (strcmp(yyjson_get_str(visual), "waveform") && strcmp(yyjson_get_str(visual), "fft")))
      return SET_ERRNO(ERROR_INVALID_PARAM, "visualization must be waveform or fft");
    option(r, yyjson_get_str(visual), "true");
    option(r, "audio", "true");
    yyjson_val *audio = mcp_get(a, "audio");
    static const char *const audio_fields[] = {"type", "path", "data_base64", "mime_type", "url", NULL};
    if (audio) {
      err = check_fields(audio, audio_fields);
      if (err)
        return err;
    }
    yyjson_val *type = mcp_get(audio, "type");
    if (type && !yyjson_is_str(type))
      return SET_ERRNO(ERROR_INVALID_PARAM, "audio.type must be a string");
    const char *t = type ? yyjson_get_str(type) : (audio_device || volume ? "microphone" : "test");
    if ((audio_device || volume) && strcmp(t, "microphone"))
      return SET_ERRNO(ERROR_INVALID_PARAM, "audio_device and volume require microphone audio");
    if (!strcmp(t, "test")) {
      if (audio && yyjson_obj_size(audio) > 1)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Test audio has no source fields");
      option(r, "test-audio", "true");
      option(r, "audio-source", "all");
    } else if (!strcmp(t, "file")) {
      if (mcp_get(audio, "url") || mcp_get(a, "audio_device") || test_audio)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Conflicting audio sources");
      err = source_file(p, audio, r);
      if (err)
        return err;
      option(r, "audio-source", "media");
      option(r, "audio-capture-source", "media");
    } else if (!strcmp(t, "url")) {
      if (mcp_get(audio, "path") || mcp_get(audio, "data_base64") || mcp_get(a, "audio_device") || test_audio)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Conflicting audio sources");
      err = source_url(p, mcp_get(audio, "url"), r);
      if (err)
        return err;
      option(r, "audio-source", "media");
      option(r, "audio-capture-source", "media");
    } else if (!strcmp(t, "microphone") && !p->restricted) {
      if (mcp_get(audio, "path") || mcp_get(audio, "data_base64") || mcp_get(audio, "url") || test_audio)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Conflicting audio sources");
      option(r, "audio-source", "mic");
      option(r, "audio-capture-source", "mic");
    } else
      return SET_ERRNO(ERROR_INVALID_PARAM, "Unsupported audio source");
  }
  if (test_audio)
    option(r, "audio", "true");
  if (tool != MCP_WEBCAM && tool != MCP_VISUALIZATION && !test_audio)
    option(r, "audio-capture-source", "media");
  yyjson_val *format = mcp_get(a, "output_format");
  if (format && (!p->restricted || !p->hosted))
    return SET_ERRNO(ERROR_INVALID_PARAM, "output_format is available only in HTTP server mode");
  if (p->restricted && p->hosted) {
    const char *ext =
        format && yyjson_is_str(format) ? yyjson_get_str(format)
        : (yyjson_is_false(mcp_get(opts, "snapshot")) || yyjson_get_num(mcp_get(opts, "snapshot-delay")) > 0) ? "mp4"
                                                                                                              : "png";
    if ((format && !yyjson_is_str(format)) || !mcp_output_mime(ext) || !output_format_available(ext))
      return SET_ERRNO(ERROR_INVALID_PARAM, "Unsupported output_format");
    unsigned char random[16];
    char token[33], path[PLATFORM_MAX_PATH_LENGTH];
    randombytes_buf(random, sizeof(random));
    sodium_bin2hex(token, sizeof(token), random, sizeof(random));
    int path_len =
        safe_snprintf(path, sizeof(path), "%s/%lld-%s.%s", p->downloads_dir, (long long)time(NULL) + 1800, token, ext);
    if (path_len < 0 || (size_t)path_len >= sizeof(path))
      return SET_ERRNO(ERROR_INVALID_PARAM, "Download path is too long");
    err = stage_output(path, r);
    if (err)
      return err;
  }
  yyjson_val *output = mcp_get(a, "output_path");
  if (output) {
    if (!yyjson_is_str(output))
      return SET_ERRNO(ERROR_INVALID_PARAM, "output_path must be a string");
    err = stage_output(yyjson_get_str(output), r);
    if (err)
      return err;
  }
  if (output_mode && !strcmp(yyjson_get_str(output_mode), "files") && !r->output_path[0])
    return SET_ERRNO(ERROR_INVALID_PARAM, "output=files requires output_path");
  return ASCIICHAT_OK;
}

References http_renderer_process_request_t::argv, ASCIICHAT_OK, http_renderer_process_request_t::capture_webcam, http_render_options_t::color_mode, mcp_policy_t::downloads_dir, enabled, ERROR_FILE_OPERATION, ERROR_INVALID_PARAM, http_render_options_t::height, mcp_policy_t::hosted, HTTP_RENDER_OUTPUT_FILE, HTTP_RENDER_OUTPUT_TEXT, index, MCP_FILE, mcp_output_mime(), MCP_REQUEST_ARGV_CAPACITY, MCP_SERVER_REQUEST_B_BUFFER_SIZE, MCP_SERVER_REQUEST_BUF_BUFFER_SIZE, MCP_SERVER_REQUEST_INDEX_BUFFER_SIZE, MCP_SERVER_REQUEST_VALUE_BUFFER_SIZE, MCP_URL, MCP_VISUALIZATION, MCP_WEBCAM, http_renderer_process_request_t::options, options_json_parse_value(), http_renderer_process_request_t::output_path, http_renderer_process_request_t::output_type, http_render_options_t::palette, http_render_options_t::palette_chars, PLATFORM_MAX_PATH_LENGTH, mcp_policy_t::restricted, SAFE_CALLOC, SAFE_SNPRINTF, safe_snprintf(), SAFE_STRNCPY, SET_ERRNO, http_renderer_process_request_t::timeout_ms, and http_render_options_t::width.

Referenced by mcp_dispatch().

mcp_tools_schema()

yyjson_mut_val * mcp_tools_schema	(	yyjson_mut_doc *	d,
		const mcp_policy_t *	p )

Definition at line 158 of file request.c.

                                                                           {
  const char *names[] = {"render_file", "render_url", "render_webcam", "render_visualization"};
  const char *descs[] = {
      "Convert uploaded media or a local file into ASCII art. Source can be omitted for test-pattern/test-audio.",
      "Convert URL media into ASCII art using the CLI media resolver.",
      "Capture a local webcam as ASCII art; test-pattern avoids camera access.",
      "Render waveform or FFT from test audio, uploaded audio, URL audio, or local audio/microphone."};
  yyjson_mut_val *tools = yyjson_mut_arr(d);
  for (int i = 0; i < 4; ++i) {
    if (p->restricted && i == MCP_WEBCAM)
      continue;
    yyjson_mut_val *tool = yyjson_mut_obj(d), *s = object_schema(d), *props = yyjson_mut_obj_get(s, "properties");
    yyjson_mut_obj_add_str(d, tool, "name", names[i]);
    yyjson_mut_obj_add_str(d, tool, "description", descs[i]);
    yyjson_mut_obj_add_val(d, props, "options", options_schema(d, p));
    property(d, s, "timeout_ms", "integer", "Maximum job time, 1000–60000 ms; default 45000.");
    if (p->restricted && p->hosted) {
      property(d, s, "output_format", "string",
               "Output format: png, jpg, jpeg, bmp, webp, gif, mp4, mov, mkv, webm, avi, flv, ogv, ogg or 3gp. "
               "Defaults to png for a single frame or mp4 for a timed or continuous render. GIF renders media to EOF "
               "unless snapshot or snapshot-delay is specified.");
      yyjson_mut_val *available = yyjson_mut_arr(d);
      for (size_t i = 0; mcp_output_formats[i]; ++i)
        if (output_format_available(mcp_output_formats[i]))
          yyjson_mut_arr_add_str(d, available, mcp_output_formats[i]);
      yyjson_mut_obj_add_val(d, yyjson_mut_obj_get(props, "output_format"), "enum", available);
    }
    if (!p->restricted)
      property(d, s, "output_path", "string",
               "Save rendered ASCII art as an image/video, selected by extension. Existing files are never replaced.");
    property(d, s, "output", "string", "Output mode: text or files. Defaults to text unless output_path is supplied.");
    const char *output_modes[] = {"text", "files", NULL};
    enum_strings(d, yyjson_mut_obj_get(props, "output"), output_modes);
    if (i == MCP_FILE)
      file_properties(d, s, !p->restricted);
    if (i == MCP_URL) {
      property(d, s, "url", "string", "HTTP/HTTPS media URL (local profile also accepts RTSP/RTMP).");
      yyjson_mut_val *required = yyjson_mut_arr(d);
      yyjson_mut_arr_add_str(d, required, "url");
      yyjson_mut_obj_add_val(d, s, "required", required);
    }
    if (i == MCP_WEBCAM) {
      property(d, s, "video_device", "integer", "Local webcam index, 0–10; default 0.");
      yyjson_mut_val *device = yyjson_mut_obj_get(props, "video_device");
      yyjson_mut_obj_add_int(d, device, "default", 0);
      yyjson_mut_obj_add_int(d, device, "minimum", 0);
      yyjson_mut_obj_add_int(d, device, "maximum", 10);
    }
    if (!p->restricted && (i == MCP_WEBCAM || i == MCP_VISUALIZATION)) {
      property(d, s, "audio_device", "integer", "Microphone index; -1 or omitted selects the system default.");
      yyjson_mut_val *device = yyjson_mut_obj_get(props, "audio_device");
      yyjson_mut_obj_add_int(d, device, "default", -1);
      yyjson_mut_obj_add_int(d, device, "minimum", -1);
      yyjson_mut_obj_add_int(d, device, "maximum", INT_MAX);
      yyjson_mut_val *volume = options_json_schema_for_option(d, "microphone-volume");
      yyjson_mut_obj_remove_str(volume, "description");
      yyjson_mut_obj_add_str(d, volume, "description", "Microphone volume multiplier, 0–1; 0 mutes, 1 is normal.");
      yyjson_mut_obj_add_real(d, volume, "default", 1);
      yyjson_mut_obj_add_real(d, volume, "minimum", 0);
      yyjson_mut_obj_add_real(d, volume, "maximum", 1);
      yyjson_mut_obj_add_val(d, props, "volume", volume);
    }
    if (i == MCP_VISUALIZATION) {
      property(d, s, "visualization", "string", "waveform or fft");
      const char *values[] = {"waveform", "fft", NULL};
      enum_strings(d, yyjson_mut_obj_get(props, "visualization"), values);
      yyjson_mut_val *audio = object_schema(d);
      property(d, audio, "type", "string", "Audio source, default test.");
      const char *types[] = {"test", "file", "url", "microphone", NULL};
      const char *remote_types[] = {"test", "file", "url", NULL};
      enum_strings(d, yyjson_mut_obj_get(yyjson_mut_obj_get(audio, "properties"), "type"),
                   p->restricted ? remote_types : types);
      file_properties(d, audio, !p->restricted);
      property(d, audio, "url", "string", "Audio URL.");
      yyjson_mut_obj_add_val(d, props, "audio", audio);
      yyjson_mut_val *req = yyjson_mut_arr(d);
      yyjson_mut_arr_add_str(d, req, "visualization");
      yyjson_mut_obj_add_val(d, s, "required", req);
    }
    yyjson_mut_val *out = object_schema(d);
    property(d, out, "ascii", "string", "Rendered text; saved media may have no terminal text.");
    property(d, out, "elapsed_ms", "integer", "Worker wall-clock duration.");
    if (p->restricted && p->hosted) {
      property(d, out, "download_url", "string", "Temporary URL for the rendered file.");
      property(d, out, "expires_at", "string", "UTC expiration timestamp in RFC 3339 format.");
    }
    yyjson_mut_val *saved = yyjson_mut_obj(d), *items = yyjson_mut_obj(d);
    yyjson_mut_obj_add_str(d, saved, "type", "array");
    yyjson_mut_obj_add_str(d, items, "type", "string");
    yyjson_mut_obj_add_val(d, saved, "items", items);
    yyjson_mut_obj_add_val(d, yyjson_mut_obj_get(out, "properties"), "saved_files", saved);
    yyjson_mut_val *required = yyjson_mut_arr(d);
    yyjson_mut_arr_add_str(d, required, "ascii");
    yyjson_mut_arr_add_str(d, required, "elapsed_ms");
    yyjson_mut_arr_add_str(d, required, "saved_files");
    yyjson_mut_obj_add_val(d, out, "required", required);
    yyjson_mut_obj_add_val(d, tool, "outputSchema", out);
    yyjson_mut_obj_add_val(d, tool, "inputSchema", s);
    yyjson_mut_arr_add_val(tools, tool);
  }
  if (!p->restricted) {
    yyjson_mut_val *tool = yyjson_mut_obj(d);
    yyjson_mut_obj_add_str(d, tool, "name", "device_list");
    yyjson_mut_obj_add_str(d, tool, "description",
                           "List local video and microphone device indices, names, and defaults.");
    yyjson_mut_obj_add_val(d, tool, "inputSchema", object_schema(d));
    yyjson_mut_val *annotations = yyjson_mut_obj(d);
    yyjson_mut_obj_add_bool(d, annotations, "readOnlyHint", true);
    yyjson_mut_obj_add_val(d, tool, "annotations", annotations);
    yyjson_mut_arr_add_val(tools, tool);
  }
  return tools;
}

References mcp_policy_t::hosted, MCP_FILE, mcp_output_formats, MCP_URL, MCP_VISUALIZATION, MCP_WEBCAM, options_json_schema_for_option(), out, and mcp_policy_t::restricted.

Referenced by mcp_dispatch().