Text Module

Runtime modules are the built-in capabilities you call from automations on the foundation, and the text module is one of them. It provides pure-JS text processing utilities, with no external dependencies.

parseUrl

Generic URL parser. Extracts standard URL parts (domain, path, query) plus Prisme.ai-specific fields (workspaceId, file id/filename).

- run:
    module: text
    function: parseUrl
    parameters:
      url: "{{uploaded_file.url}}"
    output: parsed
# parsed.domain      → "api.prisme.ai"
# parsed.path        → "/v2/files/ws123/abc.report.pdf"
# parsed.id          → "abc"
# parsed.filename    → "report.pdf"
# parsed.ext          → "pdf"
# parsed.workspaceId → "ws123"
# parsed.mimetype    → "application/pdf"
# parsed.query       → { "token": "xyz" }

Parameter	Type	Required	Default	Description
`url`	string	yes		Any URL (or raw string)

Returns an object with the following fields:

Field	Type	Description
`domain`	string	Hostname (e.g. `api.prisme.ai`). Empty for non-URLs.
`path`	string	Full pathname (e.g. `/v2/files/ws123/abc.report.pdf`).
`id`	string	From the last path segment: everything before the first dot, only when 2+ dots are present. Empty otherwise.
`filename`	string	From the last path segment: everything after the first dot. If no dot, equals the full segment.
`ext`	string	Lowercase file extension from the filename (e.g. `pdf`, `xlsx`). Empty if none.
`workspaceId`	string	Extracted from `/files/{wsId}/…` or `/workspaces/{wsId}/…`. Empty if not found.
`mimetype`	string	MIME type inferred from the file extension.
`query`	object	Query string parameters as key-value pairs.

How `id` / `filename` splitting works

The last path segment is parsed based on the number of dots:

2+ dots ({id}.{name}.{ext}): id is everything before the first dot, filename is the rest.
1 dot ({name}.{ext}): the whole segment is the filename, no id.
0 dots: the whole segment is the filename, no id.

Last segment	`id`	`filename`
`abc123.report.pdf`	`abc123`	`report.pdf`
`doc.pdf`	(empty)	`doc.pdf`
`README`	(empty)	`README`

Examples

Extract a file ID from a native upload URL:

- run:
    module: text
    function: parseUrl
    parameters:
      url: "{{file_part.url}}"
    output: _parsed
- set:
    name: file_id
    value: "{{_parsed.id}}"

Extract workspace ID from any Prisme.ai URL:

- run:
    module: text
    function: parseUrl
    parameters:
      url: "{{webhook_url}}"
    output: _parsed
- set:
    name: ws_id
    value: "{{_parsed.workspaceId}}"

splitText

Split text into chunks using a recursive character splitting strategy. The splitter tries separators in order, splits on the first one found, merges small pieces back up to chunkSize, maintains chunkOverlap between consecutive chunks, and recurses with finer separators for pieces still too large.

- run:
    module: text
    function: splitText
    parameters:
      content: "{{document.text}}"
      chunkSize: 1000
      chunkOverlap: 200
    output: chunks

Parameter	Type	Required	Default	Description
`content`	string \| string[]	yes		Text or array of texts to split
`chunkSize`	number	yes		Maximum size of each chunk (in characters)
`chunkOverlap`	number	yes		Number of overlapping characters between consecutive chunks
`separators`	string[]	no	`["\n\n", "\n", " ", ""]`	Ordered list of separators to try, from coarsest to finest
`keepSeparator`	boolean \| `"start"` \| `"end"`	no	`false`	Attach the separator to the chunk. `true` or `"end"` appends it to the preceding chunk, `"start"` prepends it to the following chunk. Only visible with non-whitespace separators (whitespace is trimmed).

Returns an array of { content, size } objects:

[
  { "content": "First chunk text...", "size": 253 },
  { "content": "Second chunk text...", "size": 241 }
]

Split with custom separators (e.g. Markdown headings)

- run:
    module: text
    function: splitText
    parameters:
      content: "{{document.text}}"
      chunkSize: 1500
      chunkOverlap: 100
      separators:
        - "\n## "
        - "\n### "
        - "\n\n"
        - "\n"
        - " "
        - ""
      keepSeparator: start
    output: chunks

Iterate over chunks

- run:
    module: text
    function: splitText
    parameters:
      content: "{{document.text}}"
      chunkSize: 500
      chunkOverlap: 50
    output: chunks
- repeat:
    on: "{{chunks}}"
    do:
      - emit:
          event: chunk-ready
          payload:
            text: "{{item.content}}"
            size: "{{item.size}}"

search

grep-like line search over a text content. Returns the matching lines with their 1-based line numbers, so an automation can act on positions without re-parsing the text.

- run:
    module: text
    function: search
    parameters:
      content: "{{document.text}}"
      pattern: "ERROR|WARN"
      ignoreCase: true
      context: 1
    output: hits
# hits.count             → number of matching lines
# hits.matches[0].line   → 1-based line number
# hits.matches[0].text   → the line (or matched substring in onlyMatching mode)
# hits.matches[0].context → true for context-only lines

Parameter	Type	Required	Default	Description
content	string	yes		Text to search.
pattern	string	yes		JS regular expression, or a literal string when `fixed` is true.
fixed	boolean	no	false	Match `pattern` literally (grep -F).
ignoreCase	boolean	no	false	Case-insensitive match (grep -i).
invert	boolean	no	false	Return the lines that do NOT match (grep -v).
context	number	no	0	Context lines before and after each match (grep -C).
before / after	number	no		Context lines before / after only (grep -B / -A).
onlyMatching	boolean	no	false	Return only the matched substrings (grep -o).
maxCount	number	no		Stop after this many matching lines (grep -m).

Returns { matches: [{ line, text, context? }], count } where count is the number of matching lines (context lines excluded).

substitute

sed-like regex substitution. Use this instead of the replace() expression helper when you need a regular expression (the expression helper is literal-only). Returns the new content and the number of replacements made, so you can detect no-ops.

- run:
    module: text
    function: substitute
    parameters:
      content: "{{document.text}}"
      pattern: "(\\d{4})-(\\d{2})-(\\d{2})"
      replacement: "$3/$2/$1"
    output: result
# result.content → text with dates reformatted
# result.count   → number of replacements

Parameter	Type	Required	Default	Description
content	string	yes		Text to transform.
pattern	string	yes		JS regular expression, or a literal string when `fixed` is true.
replacement	string	yes		Replacement, with `$1`..`$n` / `$<name>` / `$&` / `$$` backreferences.
fixed	boolean	no	false	Match `pattern` literally.
ignoreCase	boolean	no	false	Case-insensitive match.
all	boolean	no	true	Replace every occurrence; set false for the first only.
lineRange	[number, number]	no		Restrict to lines in the inclusive 1-based range (sed addresses).

Returns { content, count }.

diff

Produces a unified diff between two texts, the complement of applyPatch. Feed the result to applyPatch to reapply the change: applyPatch(a, diff(a, b).patch) yields b.

- run:
    module: text
    function: diff
    parameters:
      a: "{{before}}"
      b: "{{after}}"
    output: d
# d.patch     → unified diff text (empty when a === b)
# d.changed   → boolean
# d.additions → lines added
# d.deletions → lines removed

Parameter	Type	Required	Default	Description
a	string	yes		Original text.
b	string	yes		Modified text.
context	number	no	3	Context lines around each change.
labelA / labelB	string	no	a / b	Labels for the `---` / `+++` header.
noHeader	boolean	no	false	Emit only `@@` hunks, without the file header.

Returns { patch, changed, additions, deletions }.

applyPatch

Applies a unified diff to a text content. Designed for LLM-generated patches: hunks are located by matching their context lines, not by trusting the @@ line numbers (models are unreliable at line arithmetic), so a patch still applies even when its line numbers are off.

- run:
    module: text
    function: applyPatch
    parameters:
      content: "{{document.text}}"
      patch: "{{generated_diff}}"
    output: r
# r.content      → patched text
# r.hunksApplied → number of hunks applied
# r.hunksFailed  → [{ index, reason, context }] for hunks that did not match

Parameter	Type	Required	Default	Description
content	string	yes		Text to patch.
patch	string	yes		Unified diff (as produced by `diff` or by a model).
fuzz	number	no	1	Whitespace tolerance when matching context: 0 exact, 1 ignore trailing whitespace, 2 ignore leading + trailing.
atomic	boolean	no	false	If any hunk fails, return the original content untouched.

Returns { content, hunksTotal, hunksApplied, hunksFailed }. A hunk that fails never corrupts the content, its reason is actionable so a model can regenerate just that hunk.

Overview

Chat

Agent Creator

Knowledges

Collections

Builder

Governe

Engage

Insights

parseUrl

How `id` / `filename` splitting works

Examples

splitText

Split with custom separators (e.g. Markdown headings)

Iterate over chunks

search

substitute

diff

applyPatch

​parseUrl

​How id / filename splitting works

​Examples

​splitText

​Split with custom separators (e.g. Markdown headings)

​Iterate over chunks

​search

​substitute

​diff

​applyPatch

parseUrl

How `id` / `filename` splitting works

Examples

splitText

Split with custom separators (e.g. Markdown headings)

Iterate over chunks

search

substitute

diff

applyPatch