Error codes

All the refusal codes of the platform: whose code it is and when it comes. The person sees the same refusal in words in the window; here is its code, to find the cause.

1 Error codes

The document is a part of the contract Exchange with the kernel: the refusal codes of the platform and the parts that answer for them. The form of an error in a message — Exchange with the kernel, section 3.

The field data of a domain error holds: error_code, category, message_key, the parameters of the text if the text takes them, retryable (whether a retry is allowed), details that may be shown, and trace_id — the trace of the call the refusal answers: the one named in the parameters of the call, or the trace of the run whose step it is (context.trace_id). A refusal that named its trace keeps it. message_key is error.<code> by default; a refusal may name its own key when one code has several causes, each with its own words, and list in names what its words speak of — nodes, variables, links. The window says the words of the key and after them what is named. So refuses process.group.detach (Methods of the graph, section 1).

Categories: protocol, config, runtime, graph, module, document, ui. The category is given by the owner of the code. The code of a part is of the category of the part: the function of the graph — graph, the function of modules and the refusals of modules — module, the function of settings — config, the workshop and the pulpit — ui, the rest — runtime. A common code and a code of a contract are of the category their owner declared beside the codes (core/protocol/src/codes.rs, the categories themselves are constants of the contract in core/protocol/src/constants.rs): the exchange — protocol, documents and paths — document, values of settings — config, codes of the contract of the function of modules — module; a code keeps this category whichever part gives it. The codes of the kernel are divided the same way — the exchange, descriptions and the register (config), documents, the rest (runtime) — and declared in core/kernel/src/codes.rs.

Each code is declared once — in the file codes.rs of its owner; codes several parts give — in the common code of the protocol (core/protocol/src/codes.rs); a code of the contract of an owner that a dependent part gives too — in the section of the owner's contract core/protocol/src/contracts/<owner>/codes.rs, its text at the owner. The text for the person is kept in the owner's dictionary under the key error.<code>; the owner of common codes is the kernel. The check in make ci does not pass if a code is in the code but not written here, written here but not declared, or has no text in both languages.

Common — core/protocol/src/codes.rs, texts at the kernel:

Table 1 — Common error codes

Code	When
`invalid_request`	a request or an answer not in form: a required field missing, a wrong type
`method_not_found`	there is no such method at the kernel or at any function
`rpc_timeout`	no answer for longer than the asker is ready to wait
`peer_closed`	the connection to the kernel broke while an answer was awaited
`function_lost`	the owner of the method disconnected or failed without answering
`function_unavailable`	the function the call is addressed to does not work now. By it and by `method_not_found` (nobody declared the method) the caller learns that an optional dependency is not there
`transport_write_failed`	a message could not be written into the channel
`document_invalid`	a document of the wrong kind: not JSON, an unknown or newer `format`, a required part missing
`document_not_found`	there is no document at this path
`document_write_failed`	a document could not be written to disk
`path_outside_root`	the path leads beyond the data folder or the installation
`process_spawn_failed`	an OS process could not be started
`settings_type`	the value of a setting is of the wrong type
`settings_range`	a number out of the allowed bounds
`settings_choice`	a value not from the closed set

The kernel — core/kernel/src/codes.rs:

Table 2 — Error codes of the kernel

Code	When
`backpressure`	the queue of requests of one part is full (`core.rpc_queue`)
`capability_denied`	the function lacks the capability the method needs, or the register does not give it
`command_conflict`	while introducing itself a function declared a method that already belongs to another
`command_id_conflict`	the same `command_id` came with other parameters
`contract_incompatible`	the function does not support the version of the contract of the kernel
`document_list_failed`	a folder in the data could not be read, or it is not a folder
`document_remove_failed`	a file or a folder could not be deleted
`document_remove_refused`	the path is too wide: a whole section is not deleted by one call
`document_too_large`	the document is larger than `core.document_max_bytes`
`function_dependency_unavailable`	the function is not started: the one it depends on is unavailable
`function_description_invalid`	the description of a function `functions/<id>/function.json` cannot be read: no file, not JSON, a foreign format, another function described. The kernel does not start such a function; the others work
`function_exited`	the OS process of a function ended
`function_handshake_timeout`	a started function did not introduce itself to the kernel within `core.function_start_timeout_ms`
`function_not_expected`	a function introduces itself that is not in the register
`function_registry_invalid`	the register of functions cannot be read: not JSON, a foreign format, a repeated id, a cycle of dependencies, a verb `cli` against the rules of File formats, section 3
`function_restart_exhausted`	the attempts to restart a fallen function are spent
`handshake_required`	the first message was not an introduction
`health_timeout`	the function did not answer the health check in time
`instance_stopping`	the instance is stopping and takes no new starts
`invalid_environment`	someone tries to pass the variables of the link to the kernel into the environment of a module
`invalid_function_command`	a function declared a method with the prefix `core.`
`invalid_launch_token`	the launch token is wrong
`line_not_framed`	a line for the `stdin` of a module without a line break at its end
`line_too_long`	a line longer than the limit of JSON Lines
`peer_mismatch`	at the other end of the socket is the wrong user or the wrong OS process
`process_limits_unavailable`	an OS process asks for limits of memory or processors, and the user's systemd in Linux does not answer; it is not started without them
`process_not_found`	there is no OS process of a module with such a `process_handle`
`process_owner_mismatch`	the `process_handle` belongs to another function
`space_budget_exceeded`	the new thing does not fit into the room the person gave the platform (`core.disk_budget_gib`)
`space_disk_full`	the new thing would take the room on the disk kept free (`core.disk_free_min_gib`)
`process_stdin_failed`	the `stdin` of a module could not be written: the program closed
`accept_failed`	the kernel could not accept a connection (an entry of the kernel journal)
`connection_limit`	there are already `core.connections_max` connections to the kernel: the new one is not accepted (an entry of the kernel journal, one while the limit holds)

The graph — functions/graph/src/codes.rs:

Table 3 — Error codes of the function of the graph

Code	When
`graph_invalid`	the scheme of a process does not pass the check: links, ports, types, shared objects, parameters of nodes; or data in a run do not fit a node: the field `take` takes is not in the packet, a value is not of the type of the variable it is written into
`graph_cycle_invalid`	a back link goes past the node of a loop
`graph_face_port_used`	a port through which a link crosses the border of a group is being taken off its face (`process.group.face`); the link is removed first
`graph_node_not_supported`	the kind of a node is unknown
`graph_no_entry`	the process has no entry point, or it points to a node that does not exist
`graph_condition_type`	a condition compares as a number a value that is not a number
`graph_iteration_limit`	a loop went over `graph.max_iterations` or `graph.max_loop_ms`
`graph_queue_overflow`	more than `graph.queue_depth` pieces of data piled up at an input of a node
`generation_incomplete`	the documents of a process are not written as one generation: the writing broke off
`file_invalid`	a file given to a process is not accepted: a part is missing or came twice, the file is larger than `graph.file_max_bytes`, the name does not fit, or the run it is given to is not going (File formats, 16.4)
`file_not_found`	the process has no file the reference names
`process_running`	the process is going now: it cannot be saved until the end of the run
`process_in_use`	a program is asked to be deleted, and another program calls it
`process_changed`	the process was saved after the checkpoint: a run cannot go on in another version
`program_off`	the program is off: a run begins only in a program that is on
`ask_closed`	the question is already closed: it was answered or the run ended
`run_not_found`	there is no run with such a `run_id`; the event has no failed run for `process.run.retry` to repeat — this refusal is told in its own words (`message_key` — `graph.retry.none`): there is nothing to repeat, a stopped run is resumed or begun anew
`resume_not_allowed`	this run cannot be resumed
`run_active`	a run with such a `run_id` is going now: there is nothing to resume, and it does not begin a second time beside itself
`module_non_idempotent_unknown`	the outcome of a step of a module is unknown, and a repetition is not harmless: the person must confirm

Modules — functions/modules/src/codes.rs:

Table 4 — Error codes of the function of modules

Code	When
`module_invalid`	the manifest of a module cannot be read or does not pass the check; in an export, a link inside a module
`secret_invalid`	the name of a secret of a module is not capital letters, digits and `_`, or the value is not one line
`module_file_refused`	the path of a file of a module leads out of its folder, to the secrets or the environment, the file cannot be read as text or is too large
`module_exists`	a module with such an id already exists
`module_needs_environment`	the module needs the Python environment of the process, and there is none
`module_environment_conflict`	the modules of a process ask for different versions of one dependency
`module_python_not_found`	none of the programs of `modules.python_candidates` starts: there is nothing to make an environment with or to start a module in Python
`module_uv_not_found`	the uv program named by the setting `modules.uv` is not there: there is nothing to make the environment of a process with
`module_install_failed`	the Python environment of a process could not be made or filled: `uv venv` or `uv pip install` ended with an error
`module_files_failed`	the files of a module or an environment could not be read or written on disk: no room, no rights
`module_gpu_full`	the video memory the module needs is held by modules busy with a step, and it did not free up within the time of the step
`module_state_in_use`	the memory of a node is asked to be reset while its node is served by a module that is up: it would save what it holds over it
`module_in_use`	a module is asked to be deleted, and a program holds it or it is up now
`module_not_found`	there is no module with such an id among those installed
`module_model_missing`	the neural network chosen by a parameter of a node or the default of the manifest is not in the folder of networks: the step does not reach the module, a service does not come up; `data.names` — the missing ones, `<kind>/<name>`
`model_in_use`	a neural network is asked to be deleted, and an installed module takes it by default; `data.names` — the modules
`model_not_found`	there is no neural network of such a kind and name in the folder of networks
`module_failed`	the step failed in the work of the module itself: the module reported a refusal itself or an error happened in its code; the manifest is in order. The cause the module named by its own code is in `data.module_error_code` (Methods of modules, 1.2)
`module_not_ready`	a step was sent to the module before it answered `init` — the order of the protocol is broken
`transport_overflow`	the module writes to `stdout` more than fits: a line too long or extra answers
`artifact_invalid`	an artifact in the answer of a module is described out of form or lies outside the work folder
`artifact_missing`	the file named as an artifact is not there
`artifact_too_large`	the artifact is larger than `modules.artifact_max_bytes`

The contract of the function of modules — core/protocol/src/contracts/modules/codes.rs, texts at the function of modules; the function of the graph gives or reads these codes too: when a process finds a recorded module different, when a stop catches a step that was still waiting to begin, and when by the code of a refusal it decides whether the outcome of a step is known:

Table 5 — Error codes of the contract of the function of modules

Code	When
`module_changed`	the files of a module did not match the print written in the process or the export
`module_missing`	the module a process stands on is not among those installed
`module_version_mismatch`	the installed version of a module is not the one written in the process
`module_cancelled`	the step of a module is cancelled: the run or the group was stopped while the step went or still waited to begin
`module_timeout`	the step did not fit into the `timeout_ms` of the manifest; the outcome of the step is unknown
`module_process_lost`	the program of the module closed or answered outside the protocol in the middle of a step; the outcome of the step is unknown
`module_memory_limit`	the program of the module took the modules past the limit of memory the person gave, and Linux stopped it in the middle of a step; the outcome of the step is unknown
`model_exists`	a neural network is being put into the folder of networks under a name already taken in its kind; the existing one is not replaced; the function of sources says so before the download begins

Settings — functions/settings/src/codes.rs:

Table 6 — Error codes of the function of settings

Code	When
`settings_unknown_key`	there is no such key in any schema
`settings_invalid`	the schema of an owner does not pass the check, or a file of a level is spoiled
`settings_invalid_level`	the level is named wrongly, or it lacks a `process_id`
`settings_invalid_owner`	the schema belongs to another owner than the one registering it
`settings_secret_rejected`	the name of the key holds a word that looks like a secret
`settings_value_invalid`	a value in a file of a level does not pass the schema and is not used (an event)

The pulpit — functions/canvas/src/codes.rs:

Table 7 — Error codes of the function of the pulpit

Code	When
`canvas_invalid`	the document of the pulpit does not pass the check
`canvas_image_invalid`	a file is not accepted as a picture of the pulpit: name, kind, content or size (File formats, 7.2)
`canvas_image_not_found`	there is no picture with such a name in the folder of the pulpit
`canvas_files_failed`	the files of the pulpit could not be read, written or copied
`canvas_look_invalid`	a look of an element is not accepted: the document `ogas.look/1`, pictures or size (File formats, 7.2)
`canvas_look_not_found`	the pulpit has no look with such a name
`canvas_piece_not_found`	there is no piece of interface with such a name in the library

Observation — functions/observe/src/codes.rs:

Table 8 — Error codes of the function of observation

Code	When
`observe_unknown_problem`	there is no problem with such an id

Languages — functions/i18n/src/codes.rs:

Table 9 — Error codes of the function of languages

Code	When
`i18n_key_missing`	there is no text for a key in the dictionaries (an event)

Sources — functions/sources/src/codes.rs:

Table 10 — Error codes of the function of sources

Code	When
`source_unknown`	there is no source with such a name in the settings
`source_unreachable`	the source did not answer: no network, the site does not answer, its certificate does not check, or the answer did not come within `sources.answer_s`
`source_answer_bad`	the source answered the wrong thing: not JSON, a showcase of another format, a thing without a required field, a file without a size or a checksum
`source_item_unknown`	the source has no such thing
`source_gated`	the source gives the thing only after signing in or agreeing to terms on its site; the platform keeps no keys
`source_too_big`	the download is larger than `sources.max_gib`
`source_no_room`	there is less room on disk than the download weighs
`source_file_bad`	the name or path of a file from the source leads out of the folder of the thing, is hidden, or is not named by the thing
`source_hash_mismatch`	the checksum of a downloaded file is not the one the source named; the file is deleted
`source_download_failed`	the file did not download: a break, an answer with an error, the file is larger than declared, or the download stood longer than `sources.stall_s`
`source_signature_bad`	the showcase of ogas.space has no signature of the site key, or it does not hold; nothing of it is shown
`download_not_found`	there is no download going with such an id

The workshop — functions/ui/src/codes.rs:

Table 11 — Error codes of the function of the workshop

Code	When
`method_not_allowed`	the window calls a method closed to it
`ui_font_unavailable`	the font file cannot be read, is of the wrong kind, or is over the limit
`ui_window_unauthorized`	the window did not present the session token
`ui_window_disconnected`	the window program is not connected to the platform: the connection is not made or is closed; given by the window program itself
`ui_window_no_answer`	the platform did not answer the window program in time; given by the window program itself
`ui_window_open_refused`	the window program does not open a file of a process with a Windows program: such a kind of file is run, not shown — a program, a script, a shortcut; given by the window program, and the file can be shown in its folder (Protection, 3.13)
`ui_window_file_failed`	the window program could not take a file of a process from the function of the graph, put its copy, or pass it to Windows: the name is not simple, the file is larger than the window copies, there is no room, or Explorer did not start
`ui_window_path_unknown`	Linux does not reach the file at the path of Windows the dialog or the Explorer named
`ui_window_shortcut_failed`	the window program could not make or take away a shortcut of Windows
`ui_window_wsl_config_failed`	the window program could not write `.wslconfig`

The door for programs — functions/gate/src/codes.rs:

Table 12 — Error codes of the function of the door

Code	When
`gate_unauthorized`	the first message of a connection is not `gate.hello` with the key of the door
`gate_busy`	as many programs have come in as `gate.clients` lets in
`gate_not_allowed`	a program calls a method that cannot be called through the door
`gate_no_key`	there is no key of the door, and making one failed

The assistant — functions/assistant/src/codes.rs:

Table 13 — Error codes of the function of the assistant

Code	When
`assistant_no_network`	the network of the assistant is not chosen
`assistant_not_a_network`	the module named as the network is not a network of the assistant
`assistant_task_not_found`	there is no task with such an id
`assistant_task_busy`	the task is working, and it is asked for something new

The profile — functions/profile/src/codes.rs:

Table 14 — Error codes of the function of the profile

Code	When
`profile_none`	there is no profile on this computer
`profile_exists`	there is a profile on this computer already
`key_code_bad`	the code does not add up, or it is the key of another profile; neither the code nor a key file is given
`key_password_bad`	the password does not open the key file
`key_file_bad`	the file is not `ogas.key/1`, cannot be read or written
`site_unreachable`	the site did not answer or answered with an error
`site_signature_bad`	a file of the site without a signature of the site key, with one that does not hold, or not of its format; nothing of it is taken
`parcel_refused`	the site did not take the parcel; its code is in the details
`parcel_bad`	the fields of the parcel are not those its kind names
`parcel_too_large`	the parcel or its things are over the limits
`parcel_not_found`	there is no such unsent parcel
`thing_not_found`	there is no program, module or piece offered
`thing_binary`	a file in a thing is neither text nor a picture
`thing_no_lock`	a module not in Python has no `Cargo.lock`