The path for which to set the value, the root is the proto. Can be a proto path or a simplified dot path.

Expression to generate the desired value. Result type must be compatible with the field in the proto that is being set.

Catalog id of the behavior to be instantiated. Can refer to a skill or a parameterizable behavior tree. References a intrinsic_proto.skills.Skill.id.

Name of a particular instance of the skill identified in the name field. The instance name should be unique among all other existing skill instances that are being used in a process. Deprecated: Do not set this field.

Single-message parameters for the skill. The executive will never modify this. The parameters actually used during execution may be (partially) resolved from parameter assignments instead.

List of parameter assignments from blackboard. Contains access path into the parameter and cel_expression to access the blackboard value.

This is a map from slot to resource name or reference. The name can then be used to retrieve a resource handle. The reference will be instantiated from a BehaviorCall.

This is the key for accessing the return value of the behavior call on the blackboard.

Deprecated: Do not fill or use this data.

Current resources for a BehaviorCall that is executing. All references in the ResourceSpecification have been replaced with the actual handles.

A name for the tree that may be used for display.

User provided data that is treated opaquely by the executive. The data is assumed to be small (all data combined in the order of kilobytes) as to not slow down state retrieval.

This is only set on retrieval by the executive. It is ignored when uploading a tree.

The blackboard scope that any blackboard key in this behavior tree is in. This is an output only field.

A unique identifier for this behavior tree. This must be unique over all subtrees and subtree conditions across all operations that are currently in the executive. This can optionally be set as an input to refer to a specific (sub-)tree later on. If it is not unique, the tree will fail to load, thus generating an UUID is advised. When not set, the executive will automatically generate a unique id. The format must follow: [a-zA-Z0-9][a-zA-Z0-9_-]*

For a parameterizable behavior tree, this field might be changed by the executive during import to guarantee uniqueness. The reason is that the same PBT can be loaded multiple times which requires the trees to have different tree ids. When calling a PBT in a TaskNode via call_behavior, use the called_tree_state field to determine the tree_id of the PBT instance.

https://cel.dev/

The node must not have a decorator condition.

Input parameters (potentially with assignments from the blackboard). Must be a message of the type specified by [parameter_message_full_name][intrinsic_proto.executive.CodeExecution.parameter_message_full_name].

Blackboard key under which to store the return value. Will be a message of type specified by [return_value_message_full_name][intrinsic_proto.executive.CodeExecution.return_value_message_full_name].

Full proto message name of the message specifying the input parameters.

Full proto message name of the message specifying the return values.

A file descriptor set containing the proto files with the message definitions for the parameter message (see [parameter_message_full_name]) and return value message (see [return_value_message_full_name]) and all transitive dependencies. Parameter and return value message are expected to be defined in the same proto file, else the code execution will fail. The file descriptor set can be created with the proto builder service.

This is only set by the executive on retrieval. It is ignored when uploading a tree.

This is only set by the executive and ignored when loading a tree. The field is set if and only if the state is FINISHED and reflects the outcome of the evaluation of this condition.

Name of the operation

The behavior tree to create the operation for

If set to true, will load the default process specified for the solution. Deprecated: Specify a behavior_tree explicitly.

Blackboard key where to store the data.

Expression to set the value of the blackboard key.

Deprecated: Replace references to blackboard_key in the behavior tree by inlining this cel_expression.

For example, given a data node: data { create_or_update { blackboard_key: "foo" cel_expression: "skill_return.bar" } }

is used in a skill call as: task { call_behavior { skill_id: "ai.intrinsic.some_skill" assignments { parameter_path: "my_param" cel_expression: "foo" } } }

then it should be replaced by: task { call_behavior { skill_id: "ai.intrinsic.some_skill" assignments { parameter_path: "my_param" cel_expression: "skill_return.bar" } } }

and eliminate the data node entirely.

The Any proto MUST be of type intrinsic_proto.executive.WorldQuery. Deprecated: Replace this, e.g., by a task node with Python code execution.

When the proto is created/updated in the blackboard it is stored unpacked. Therefore the proto must be of a type that is a well-known or skill proto.

All protos must be of a type that is a well-known or skill proto. The protos are stored packed in the blackboard. Deprecated: If used with a for each loop, replace that loop by a while loop.

If set, the enclosing operation will be suspended when this node is selected for execution.

Condition to denote whether a SELECTED node can transition to RUNNING. If the condition is unsatisfied when a node is selected the node transitions to FAILED.

Name of the operation

Name of the operation

If DISABLED, do not set the resulting state based on execution semantics, but force the resulting state. Only SUCCEEDED or FAILED are valid.

The blackboard key where the ExtendedStatus is stored. This must have previously been set using the on_failure decorator to emit an extended status.

Match a specific status code. If component is empty or code is zero it is ignored for the match, e.g., enabling to match any error of a specific component.

An optional extended status to emit. If the extended status is given, it is emitted to the given blackboard key and children’s extended statuses (if any) are added to context. If the field is not set, a propagated extended status is emitted to the given blackboard key, or if multiple extended statuses are propagated a collector status is auto-generated with these statuses as context.

Emit extended status available for this node (on failure) to the given blackboard key. This can then be used, for example, as a condition (ExtendedStatusMatch).

Exactly one of these fields must be set.

Do not use. Prefer tries.

Blackboard key that the currently looped over value will be available on. This is one entry of the for_each field.

A list of protos, where the loop node executes one cycle for each proto. In the n-th cycle the n-th proto is available with the key specified in value_blackboard_key. The protos must be of a type that is in the transitive closure of all well-known or skill proto types. The value is internally unpacked, e.g., if a Pose proto is specified, its values are accessible and within a for_each loop an expression like current_value.x would be valid (assuming the value_blackboard_key is "current_value").

A CEL expression to generate an array of protos, e.g., retrieving a repeated field of some proto in the blackboard. If the data is generated, e.g., by a DataNode, this is simply the data node's blackboard_key to which the result was written (using create_or_update).

https://cel.dev/

A blackboard key is scoped based on where it is defined, use: "PROCESS_TREE" for an item in the process tree. For example to retrieve the return value of a skill that just ran. This is the default for most use cases. This is the default, if scope is not set.

Name of the operation

Name of the operation

The following enables to limit the data that is returned in the operation's metadata field (of type RunMetadata in the Any proto). If not set returns the full metadata. A typical limited mask could be "paths: behavior_tree.state" to get only the behavior tree's overall state. If this is set to an empty FieldMask (nothing in FieldMask.paths), the metadata field will not be filled.

Use a predefined view.

Full proto message name of the message specifying the input parameters. This should be the same as [CodeExecution.parameter_message_full_name][intrinsic_proto.executive.CodeExecution.parameter_message_full_name].

Full proto message name of the message specifying the return values. This should be the same as [CodeExecution.return_value_message_full_name][intrinsic_proto.executive.CodeExecution.return_value_message_full_name].

A file descriptor set containing the proto files with the message definitions for the parameter message (see [parameter_message_full_name]) and return value message (see [return_value_message_full_name]) and all transitive dependencies. Parameter and return value message are expected to be defined in the same proto file, else an error will be returned. This should be the same as [CodeExecution.file_descriptor_set][intrinsic_proto.executive.CodeExecution.file_descriptor_set].

A template string containing the placeholder "{compute_body}" for the user's python code. When expanded, produces a full, valid Python script Also see [PythonCode][intrinsic_proto.executive.PythonCode].

Flat list of all full message names in [types_with_versions].

Transitively closed file descriptor set containing all well-known types.

Nested list of all well-known types in which all versions of "the same type" are grouped together. The types in this list are guaranteed to have a [TypeWithVersions.display_name] which is unique within this list.

Limit the request to a specific scope. Will return all blackboard values, if not set.

Name of the operation

Maximum number of iterations to perform. This cannot be set in the case of a for_each loop.

Deprecated: Use a while loop instead

This is only set on retrieval by the executive. It is ignored when uploading a tree.

An optional (display) name for the node.

An identifier for the node. The identifier must be unique for the behavior tree containing the node. Given a subtree (TREE-A), which gets used in another tree (TREE-B), both TREE-A and TREE-B may contain a node with id 1, but TREE-A (and TREE-B) may both only contain one node with id 1. This would be forbidden:

| sequence a | | id: 1 |

      |
 ----------
 | task a |
 | id: 1  |
 ----------

While this would be allowed:

| sequence a | | id: 1 |

      |

| subtree a | | id: 2 |

     |
 ----------
 | task b |
 | id: 1  |
 ----------

An optional description for a node. This can be used, for example, to provide documentation for a particular node.

User provided data that is treated opaquely by the executive. The data is assumed to be small (all data combined in the order of kilobytes) as to not slow down state retrieval.

Proto field path into the parameters message. Examples of supported path syntax: - Top-level field: "target_pose" - Nested field: "target_pose.position.x" - Repeated field: "target_poses[3]" or "target_poses[3].position" - Append to repeated field: "target_poses[]" ([] is only allowed in the last path element, i.e., after the last ".") Map fields are not supported.

Name of the file in the result file descriptor set to contain the input proto.

Package for the enclosed type

A set of descriptors which use only basic (int64, string etc.) and well-known (cf. GetWellKnownTypes) types.

Name of the operation

If set to true, the blackboard of the operation will not be reset and all keys are kept.

Name of the operation

These fields will be initialized when starting a behavior tree (not immediately when creating it).

The field is initialized when starting a behavior tree (not immediately when creating it).

This context is set when getting the operation info via the service. It contains the session ID and possibly the ID of the current runnable. It will not contain an action ID. The field is not set for logged executive states (which already are associated with a context anyway). The IDs can be used to query other relevant data.

These fields are set, if the operation is configured to execute only a specific node of a sub-behavior tree of the loaded behavior tree.

These fields are set and updated after the operation is started. Time the operation was started in UTC.

Time the operation was actively executing, e.g., excluding preparing to start, being suspended or done.

This contains diagnostics information for the current operation. These are not errors, but warnings and informational messages. After a successful call to CreateOperation this may generate diagnostics that could be reported to the user.

The scene ID that is associated with this operation. This is the starting state for the world in which this operation is running/ ran. This is only set once the operation transitions from ACCEPTED to RUNNING, and only if it was set when starting the operation. It is cleared when the operation is reset.

Deprecated: Use operation_state instead of behavior_tree_state.

Exactly one of these fields must be set.

Use the branches field instead.

Name of the operation

tree_id and node_id identify the node to change settings for. tree_id and node_id must be in the operation identified by name and node_id must be in the tree identified by tree_id.

The respective node_id to set (see tree_id).

New settings to apply for this node.

The footprint (required resources etc.) of the skill.

Arbitrary internal data from prediction. This could be anything and you cannot make any assumptions on the structure. Since it's passed from a call to predict to the call of execute on the exact same skill, it can know what to expect.

When set, use the specified timeout instead of the default timeout when calling skill.predict() (report failure if predict does not finish within this time bound).

When set, use the specified timeout instead of the default timeout calling skill.execute() (report failure if execute does not finish within this time bound).

Name of the operation

Optionally select a specific node in the operation to be executed instead of the full tree. start_node_id must be in start_tree_id and start_tree_id must be part of the named operation. start_node_id will be executed as if it were the root of start_tree_id and as if start_tree_id were the process tree of the operation. No other parts of the tree will be executed.

The respective start_node_id to start (see start_tree_id).

Parameters for the tree. Must be set if the behavior tree that the operation was created with sets the parameter_message_full_name field in its description.

This also works when specifying a start_tree_id/start_node_id to only run parts of the process. In every case the parameter specification is taken from the operation's tree.

This is a map from slot to the name of the resource handle.

The scene ID to be associated with this operation. This specifies the starting state for the world in which this operation will run. If this value is not set, the operation will run in the world in its current state.

By default the DebugNode will transition to SUCCEEDED on resume. In some situations, like in the context of a fallback node, it may be desirable to enter the FAILED state on resume. This is done if set to true.

Name of the operation

This is only set by the executive on retrieval. It is ignored when uploading a tree.

Exports the BehaviorTree and its state, if this task node executes a parameterizable behavior tree. This is only set by the executive on retrieval. It is an error when uploading a tree.

Call a skill or Parameterizable Behavior Tree.

Execute a code snippet.

If the condition is not given, a "true" condition is assumed.

The node must not have a decorator condition.

A short display name for the version, e.g., "v1" or "unversioned". May be empty if a type has only one version.

A short name for the type, e.g., "Pose" or "ObjectReference" to be shown, e.g. in a UI. Typically equal to the message name without the package. But may contain additional content (including whitespace and special characters) for disambiguation.

All versions for this type identified by their full message name. Contains at least one element. The first element is the recommended version which, e.g., can be shown by UIs as the default choice.

Execute normally, i.e., process loaded behavior tree.

Execute step-wise, i.e., stop after the execution of a node.

an unknown error occurred

condition decorator unsatisfied

error while executing the tree

As if the field was not set, see below.

Set execution mode to normal and resume

Take a step and select the next node. Only valid in step-wise mode.

Mark sub-trees of node that caused last step-wise suspend to not trigger a suspend and continue execution. First non-marked node triggers a suspend again. Only valid in step-wise mode.

Executes in real or with simulator as close to reality as possible.

Executes skills by using preview and visualizing updates.

Executes skills by using preview without visualization.

Leave skill traces as individual traces and provide links to these as attributes in task nodes.

Embed skill traces as part of the current behavior tree trace.

User-invoked cancellation is ongoing.

Cancellation after execution has timed out is ongoing.

Default value, will not occur on retrieval.

Tree has been loaded successfully.

Tree is currently executing.

Tree is waiting for in-flight actions to complete.

Tree has been paused (and can be resumed),

Tree is waiting for cancellation to finish.

Tree has finished execution successfully.

Tree has failed to execute.

Tree was canceled as requested.

Default value, will not occur on retrieval.

Operation has been loaded successfully.

Operation is preparing to start execution.

Operation is currently executing.

Operation is waiting for in-flight actions to complete.

Operation has been paused (and can be resumed),

Operation is waiting for cancellation to finish.

Operation has finished execution successfully.

Operation has failed to execute.

Operation was canceled as requested.

Currently this corresponds to ANY_TYPEURL_ONLY

Full view, corresponds to "no fieldmask"

Only report state, not runnable (behavior tree).