Automation Code Steps

Audience: Developers

Purpose: Explains how Automation Code Steps work in Kizen and provides guidance for writing, executing, and managing custom JavaScript within automations.

Overview

Code steps provide powerful, secure, and flexible scripting to Kizen Automations using Python. Code Steps natively integrate with automation variables and field values from your custom object entities. All code runs in an isolated container.

Available Runtimes

• Python 3.12

• Python 3.13

In addition to packages included in the Python Standard Library, the following packages come pre-installed:

• awslambdaric

• bcrypt

• lxml

• msgpack

• numpy

• paramiko

• pytz

• requests

• pyjwt

• tzdata

• pypdf

Note: If you have a library you would like for us to consider adding, send us a note at [email protected].

Limits

• 1 GB RAM

• 30 sec execution time

For more information see, Log Message Limits.

---

Using Inputs and Generating Outputs

Your python code will access input data in an object named inputs and write to an object named outputs. The names of the attributes are set when you select inputs and outputs in your Kizen Automation.

This example assumes an input called “name” and an output called “greeting”

outputs.greeting = "hello, " + inputs.name + "!"

---

Logging

You may write logs using the provided outputs.log() function.

Example:

from datetime import datetime
outputs.log(f"Started at: {datetime.now()}")

To view these logs:

1. Open the Automation History, for example by navigating to entity record you’ve run this automation on, and clicking the “Automation Name” for an execution in the list.

1. Then — in the Automation History view — click the Execution Status in Code Step Action (the word “Completed” in the screenshot):

1. You will see your Execution details, including any logs you’ve written:

Log Message Limits

Each call to output.logs() supports a maximum message size of 8 KB. Messages that exceed this limit are truncated.

In addition, the combined size of all log messages generated during a single code step execution is limited to 100 KB. Once this limit is reached, any additional log messages are discarded.

To avoid losing diagnostic information:

• Keep log messages short and focused

• Avoid logging large data structures or verbose output, especially inside loops

• For larger content, write values to fields or upload files, which support larger data sizes

---

Validating Inputs and Raising Errors

You can raise an Exception to immediately stop execution of your Python code due to invalid data or other unexpected cases.

outputs.log("Checking for Aristotle...")

if inputs.first_name == 'Aristotle':
    raise ValueError("Unexpected Mathematician")
else:
    outputs.greeting = f"Hello, {inputs.first_name}!"

This error will be visible in the Execution details:

A successful execution will show the inputs, outputs, and logs (more detail on the encoding of inputs and outputs later in this document):

---

Making HTTP Requests

The ability to send HTTP requests enables powerful, flexible integrations.

import requests

resp = requests.post(
  "https://httpbin.org/anything",
  json={"greeting": "Hello, world!"}
)
outputs.log(f"Got {len(resp.content)} bytes")

Integration Secrets

You may also configure your Code Step with access to use Integration Secrets.

import requests

my_secret = secrets["magicword"]

resp = requests.get(
    "https://httpbin.org/anything",
    headers={"Authorization": f"Bearer {my_secret}"}
)
outputs.log(resp.text)

HTTP Request Logs

In addition to messages you log directly in your code, HTTP requests are logged automatically.

In your HTTP request logs you’ll find:

• Total number of HTTP requests sent

• Detailed logs of the first 100 requests sent:

  • HTTP Method

  • URL

  • Request and Response Headers

  • Request Body (truncated to the first 1 kB)

• Number of requests sent without capturing detailed logs (due to exceeding the 100-request threshold)

This info will appear in the Execution Details:

---

Kizen Data Types and Data Encoding

When you view the Automation History for a Code Step, or use the Immediate/sync API for CodeRunner you will see your Kizen values encoded as JSON using the following scheme:

Boolean	b	{"t": "b", "v": "false"}
Date	d	{"t": "d", "v": "2024-12-25"}
DateTime	dt	{"t": "dt", "v": "2024-03-14T01:59:26.535897+00:00"}
Number	n	{"t": "n", "v": "3.14"}
Phone Number	p	{"t": "p", "v": "[phone]"}
String	s	{"t": "s", "v": "Hello, World!"}
UUID	u	{"t": "u", "v": "c6f9fe22-9d2c-4dca-9380-ab9733c85303"}
Entity Record	e<uuid>	The UUID in the type code indicates which Custom Object the entity is part of. { "t": "e<06e86916-cc8e-4622-af2f-8e9c08e9225b>", "v": "643eb36c-744c-4928-8e21-077acb65eaef" }
Field Option	o<uuid,uuid>	The first UUID in the type code is the Custom Object id, the second UUID is the Field id. { "t": "o<f87c4d49-9de2-4701-a7d1-73eda1783e25,28ca3e62-592e-4036-a7a9-0e2fd500d8f5>", "v": "24fb871d-f1df-42a9-8dac-1adb24bb03f6" }
Array (typed)	a[...]	{ "t": "a[s]", "v": ["Einstein", "Newton", "Pythagoras"] }
List (untyped)	l	Note: Values are individually encoded, may be an empty list, and may be null. { "t": "l", "v": [ {"t": "b", "v": "false"}, {"t": "d", "v": "2024-12-25"} ] }
File	a["f"]	Note: The value will be a valid file ID. {"t": "f","v": ["c6f9fe22-9d2c-4dca-9380-ab9733c85303", "d7a0fe33-0e3d-5edb-a491-bc0844d96414"]}