blokctl 1.2.0 → 1.4.0

package/dist/scaffold-repo/triggers/grpc/CHANGELOG.md

@@ -0,0 +1,143 @@
+# @blokjs/trigger-grpc
+
+## 0.2.0
+
+### Minor Changes
+
+- Initial public release of Blok packages.
+
+  This release includes:
+
+  - Core packages: @blokjs/shared, @blokjs/helper, @blokjs/runner
+  - Node packages: @blokjs/api-call, @blokjs/if-else, @blokjs/react
+  - Trigger packages: pubsub, queue, webhook, websocket, worker, cron, grpc
+  - CLI tool: blokctl
+  - Editor support: @blokjs/lsp-server, @blokjs/syntax
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/shared@0.2.0
+  - @blokjs/helper@0.2.0
+  - @blokjs/runner@0.2.0
+  - @blokjs/api-call@0.2.0
+  - @blokjs/if-else@0.2.0
+
+## 0.0.14
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.26
+  - @blokjs/if-else@0.0.30
+  - @blokjs/api-call@0.1.29
+
+## 0.0.13
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.25
+  - @blokjs/if-else@0.0.29
+  - @blokjs/api-call@0.1.28
+
+## 0.0.12
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.24
+  - @blokjs/if-else@0.0.28
+  - @blokjs/api-call@0.1.27
+
+## 0.0.11
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.23
+  - @blokjs/if-else@0.0.27
+  - @blokjs/api-call@0.1.26
+
+## 0.0.10
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.22
+  - @blokjs/if-else@0.0.26
+  - @blokjs/api-call@0.1.25
+
+## 0.0.9
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.21
+  - @blokjs/if-else@0.0.25
+  - @blokjs/api-call@0.1.24
+
+## 0.0.8
+
+### Patch Changes
+
+- added GRPC remote node execution server and client (NodeJS)
+- Updated dependencies
+  - @blokjs/helper@0.1.5
+  - @blokjs/runner@0.1.20
+  - @blokjs/if-else@0.0.24
+  - @blokjs/api-call@0.1.23
+
+## 0.0.7
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.19
+  - @blokjs/shared@0.0.9
+  - @blokjs/if-else@0.0.23
+  - @blokjs/api-call@0.1.22
+
+## 0.0.6
+
+### Patch Changes
+
+- Added examples and create project' command to include examples and 'create node' command with options for type ('module' or 'class') and template ('class' or 'ui')
+- Updated dependencies
+  - @blokjs/if-else@0.0.22
+  - @blokjs/api-call@0.1.21
+  - @blokjs/runner@0.1.18
+  - @blokjs/shared@0.0.8
+
+## 0.0.5
+
+### Patch Changes
+
+- Successfully implemented all the enhancements and improvements identified during our internal hackathon.
+
+## 0.0.4
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.17
+  - @blokjs/if-else@0.0.21
+  - @blokjs/api-call@0.1.20
+
+## 0.0.3
+
+### Patch Changes
+
+- Added support for YAML, XML and TOML in the workflow file. Upgraded package version recommended by Dependabot.
+- Updated dependencies
+  - @blokjs/if-else@0.0.20
+  - @blokjs/api-call@0.1.19
+  - @blokjs/helper@0.1.4
+  - @blokjs/runner@0.1.16
+  - @blokjs/shared@0.0.7
+
+## 0.0.2
+
+### Patch Changes
+
+- Implemented grpc client library

package/dist/scaffold-repo/triggers/grpc/README.md

@@ -0,0 +1,25 @@
+# Use the gRPC protocol instead of the Connect protocol
+
+On Node.js, we support three protocols:
+
+1. The gRPC protocol that is used throughout the gRPC ecosystem.
+2. The gRPC-Web protocol used by grpc/grpc-web, allowing servers to interop with grpc-web front-ends without the need for an intermediary proxy (such as Envoy).
+3. The new Connect protocol, a simple, HTTP-based protocol that works over HTTP/1.1 or HTTP/2. It takes the best portions of gRPC and gRPC-Web, including streaming, and packages them into a protocol that works equally well in browsers, monoliths, and microservices. The Connect protocol is what we think the gRPC protocol should be. By default, JSON- and binary-encoded Protobuf is supported.
+
+So far, we have been using the ```http://``` scheme in our examples. We were not using TLS (Transport Layer Security). If you want to use gRPC and browser clients during local development, you need TLS.
+
+Actually, that only takes a minute to set up! We will use ```mkcert``` to make a certificate. If you don't have it installed yet, please run the following commands:
+
+```bash
+brew install mkcert
+mkcert -install
+mkcert localhost 127.0.0.1 ::1
+export NODE_EXTRA_CA_CERTS="$(mkcert -CAROOT)/rootCA.pem"
+```
+
+If you don't use macOS or ```brew```, see the mkcert docs for instructions. You can copy the last line to your ```~/.zprofile``` or ```~/.profile```, so that the environment variable for Node.js is set every time you open a terminal.
+
+If you already use ```mkcert```, just run ```mkcert localhost 127.0.0.1 ::1``` to issue a certificate for our example server.
+
+Reference:
+https://connectrpc.com/docs/node/getting-started/

package/dist/scaffold-repo/triggers/grpc/buf.gen.yaml

@@ -0,0 +1,11 @@
+version: v2
+clean: true
+plugins:
+  - local: protoc-gen-es
+    opt: target=ts
+    out: src/gen
+    include_imports: true
+  # - local: protoc-gen-connect-es 
+  #   opt: target=ts
+  #   out: src
+  #   include_imports: true

package/dist/scaffold-repo/triggers/grpc/buf.yaml

@@ -0,0 +1,9 @@
+version: v2
+breaking:
+  use:
+    - FILE
+lint:
+  use:
+    - STANDARD
+modules:
+  - path: proto

package/dist/scaffold-repo/triggers/grpc/localhost+2-key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDNjfXRKBwXU0IH
+ftJJGiR5w6Ccf2JfPZJgDdarhVgJjL2cy9d4AwIq4ydiuU+H8MnguzdGrFaCgYOB
+GfgEI4dOAGr1AInRVVHRWKvwGdLYm59dBRi5PQuU2EKVonQNsZy/qcOJSBzBSSAx
+PFCpTwrxj0j/Dug6LxIa1wB7UenYn5NjkFSF8F5HufE7l4goIVh0/fVgRripCsnk
+iMQFVhMr+2glX+19zTVkBl9EtAPbkXsegUUdnkOH2sd1TBN4HUibnktX+P1aIlhd
+p741Eni42jU92u33iZasvvnkA94Q2MhBhzx3lgqAAcHcePzBI9yOEQbTqik4Nkpv
+moqqDFBbAgMBAAECggEACDu0aeFCZsjF70jsIVNzvJDSYRJVHV14/HHxdENOCGvj
+uGENy1fLgW5ByJmFjvtdCqxVBXanrGiFnOkuXvQRWlV380JHQuQ497qmgGJ4aIar
+Nm2a1OiWCysyV43/OgEwNxkUpO4HgNJuAKrazD1HQe+sS9MMCDCUeBC+izH3vN5s
+9LWOrhde+ZwCkHJgRxp6V5HBJXU/27T02ZjgvPXupzXQ2ozRgx2gn5lLvJJfqG/h
+jEMi9qyuwoRUL4QXDg3TNHHSllnENdRrVJr7VsvYpRpQogVsr4V7zIZiFkAcbuC4
+kMuHeahkjqmlSYVuz9DxPHcmFRW/B5MI5MLQwCvI6QKBgQD61emfMrA323QIWF5l
+hbNQBS3hje9pwN27EU3QmCq0z/2Ja0TTaSeNSdlQAfMEGHsO5tL0ldqS267uqs5r
+clrukrOFmcARZiHne5U1uMcWgYvRmPTTdwng1lQSBuLo7XR9f6sW3u1csOJ8PY4w
+oKtsAIKm0r53iVRCPpd7D9Lr3QKBgQDRyWIccS93kI2rmRxkg4nhniCP8uAacYHy
+ZEZUFpm0p23rLKF7zlGd1xZmwKV5lnd1278qBt9YMvDGw6Mlt3WTQUh9XQ3b5q1V
+xOHfyn2QvWfFbX/tWousq2RP3CJakGiKMefSx8aZB/Vwat3kSdgz825Vcr9oN2j1
+lZZemRlllwKBgD+K1QXpN07PHxPGHxOkzQnmZfsPk6i8nO74sTe4dIkdb2LSc7sC
+lmxqWsyz0bYl5Xae7q3bEGXHlQcM6gG6FGL/cs7TZh6COvCDFAdp6bU/2AWes9al
+/zCf2ug+KllLXgk0wEio7IRgot9KUKzs5sATWQWduXZaqaemZ4VbOtlZAoGAK457
+b1pUt6dssq8khP4Gl7CEJD8SJotgppoJPBZBLZABs21dzd3FdlcdEJJ5COijvvW0
+GB67Ko3RDgO6kO8pWzyXt2elo/2eCYvKNfPN5EpfDE+y2u4Mx/oB5s7W1yTaf67i
+6hGOe2F6pS+bCHYIjKjDRLyBXzr58NtxEA0Lh9sCgYEA6dI03OhJpruHxyOE3HYE
+oSDah3wr8WUw5BsGDsrW2tMVV7Y3YRO02mL/DB17bmM1FzS5s0n8DKU0c2wViFm4
+ZI4wZdm1hA1MBQBEFVQlVkmwtfyhmsnr98Huckd58PfMUZf6KJE9L4h7SXtPa/VL
+492ASgwAEWWqFlfK6wSrHiM=
+-----END PRIVATE KEY-----

package/dist/scaffold-repo/triggers/grpc/localhost+2.pem

@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEoTCCAwmgAwIBAgIRAKSu5ey0gTHNC82jEhdfdpYwDQYJKoZIhvcNAQELBQAw
+gbExHjAcBgNVBAoTFW1rY2VydCBkZXZlbG9wbWVudCBDQTFDMEEGA1UECww6bWFy
+Y29ATWFyY29zLU1hY0Jvb2stUHJvLmxvY2FsIChNYXJjbyBDYXN0aWxsbyBEZWxs
+YSBTZXJhKTFKMEgGA1UEAwxBbWtjZXJ0IG1hcmNvQE1hcmNvcy1NYWNCb29rLVBy
+by5sb2NhbCAoTWFyY28gQ2FzdGlsbG8gRGVsbGEgU2VyYSkwHhcNMjUwMjAzMDE1
+MjM5WhcNMjcwNTAzMDE1MjM5WjBuMScwJQYDVQQKEx5ta2NlcnQgZGV2ZWxvcG1l
+bnQgY2VydGlmaWNhdGUxQzBBBgNVBAsMOm1hcmNvQE1hcmNvcy1NYWNCb29rLVBy
+by5sb2NhbCAoTWFyY28gQ2FzdGlsbG8gRGVsbGEgU2VyYSkwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDNjfXRKBwXU0IHftJJGiR5w6Ccf2JfPZJgDdar
+hVgJjL2cy9d4AwIq4ydiuU+H8MnguzdGrFaCgYOBGfgEI4dOAGr1AInRVVHRWKvw
+GdLYm59dBRi5PQuU2EKVonQNsZy/qcOJSBzBSSAxPFCpTwrxj0j/Dug6LxIa1wB7
+UenYn5NjkFSF8F5HufE7l4goIVh0/fVgRripCsnkiMQFVhMr+2glX+19zTVkBl9E
+tAPbkXsegUUdnkOH2sd1TBN4HUibnktX+P1aIlhdp741Eni42jU92u33iZasvvnk
+A94Q2MhBhzx3lgqAAcHcePzBI9yOEQbTqik4NkpvmoqqDFBbAgMBAAGjdjB0MA4G
+A1UdDwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDATAfBgNVHSMEGDAWgBTN
+imcw8dRZ+LdM83iq2xnhRgHVMjAsBgNVHREEJTAjgglsb2NhbGhvc3SHBH8AAAGH
+EAAAAAAAAAAAAAAAAAAAAAEwDQYJKoZIhvcNAQELBQADggGBAIA2HiGT0dtdkNfB
+LFAIUvlatqHkH4Pds3jd0TnT4muoebPoHc3HSoqnSdt4g2vN+75S47G7E5b/qQbH
+ZfkL9kgZoCar79DuVpC/kCPI/NACRsqdgIcnd09FqN2Dmg1UP2F/nulLucWfOiSL
+T3q3nVEAm3UL4R5VopFW94bp8jJ/cWseDohIGZBza4yUiMnbd6mK+g+DoExfGbwc
+A3601xeDWcDxKv+KaBWQeyoUWO66FKYOJcdwaiPCPrvXVz3tdbxBpHB/beNeulaU
+6EzDRCmtIwEZNwq9MNn0wViOjta1TtkeERtbvnmgPmFhhSbHDtGbbxuwWnV91aZg
+0JFymKsmmBIv4Qu50zVPo7Jz0n6CucIPVUW8ZoamVBr6ljHOfZIg9N0hkRoX7DUT
+pPV22KliCRZCHYnyVcIzwtW2lxlzydUnldhxZga6vlfoKR5WzCceTtsX2+p8dbJe
+p5jVRsLyT/sfECb8n5N7BYRLSh36FekFGErFCr9Svqd9pRVsWg==
+-----END CERTIFICATE-----

package/dist/scaffold-repo/triggers/grpc/package.json

@@ -0,0 +1,61 @@
+{
+	"name": "@blokjs/trigger-grpc",
+	"version": "1.4.0",
+	"files": ["dist"],
+	"description": "",
+	"type": "module",
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"repository": "https://github.com/well-prado/blok.git",
+	"author": "Marco A. Castillo Della Sera",
+	"license": "Apache-2.0",
+	"scripts": {
+		"dev": "bun --watch run src/index.ts",
+		"start": "bun run dist/index.js",
+		"reload": "bun --env-file=.env.local run src/index.ts",
+		"build": "rimraf ./dist && tsc && copyfiles -u 1 proto/** dist/proto",
+		"build:proto": "npx buf generate .",
+		"test": "vitest run",
+		"test:dev": "vitest"
+	},
+	"devDependencies": {
+		"@bufbuild/buf": "^1.64.0",
+		"@bufbuild/protoc-gen-es": "^2.11.0",
+		"@connectrpc/protoc-gen-connect-es": "^1.7.0",
+		"@types/node": "^22.15.21",
+		"copyfiles": "^2.4.1",
+		"rimraf": "^6.1.2",
+		"typescript": "^5.8.3",
+		"vitest": "^4.0.18"
+	},
+	"dependencies": {
+		"@bufbuild/protobuf": "^2.11.0",
+		"@connectrpc/connect": "^2.1.1",
+		"@connectrpc/connect-fastify": "^2.1.1",
+		"@connectrpc/connect-node": "^2.1.1",
+		"@blokjs/api-call": "^1.4.0",
+		"@blokjs/helper": "^1.4.0",
+		"@blokjs/if-else": "^1.4.0",
+		"@blokjs/runner": "^1.4.0",
+		"@blokjs/shared": "^1.4.0",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/exporter-prometheus": "^0.57.2",
+		"@opentelemetry/resources": "^1.30.1",
+		"@opentelemetry/sdk-metrics": "^1.30.1",
+		"@opentelemetry/semantic-conventions": "^1.39.0",
+		"fast-xml-parser": "^5.3.4",
+		"fastify": "^5.7.2",
+		"uuid": "^11.1.0"
+	},
+	"peerDependencies": {
+		"@bufbuild/protoc-gen-es": "2.11.0",
+		"@connectrpc/connect": "2.1.1"
+	},
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/dist/scaffold-repo/triggers/grpc/proto/workflow.proto

@@ -0,0 +1,33 @@
+syntax = "proto3";
+
+package blok.workflow.v1;
+
+message WorkflowRequest {
+    string Name = 1;
+    string Message = 2;
+    string Encoding = 3;
+    string Type = 4;
+}
+
+message WorkflowResponse {
+    string Message = 1;
+    string Encoding = 2;
+    string Type = 3;
+}
+
+enum MessageEncoding {
+    BASE64 = 0;
+    STRING = 1;
+}
+
+enum MessageType {
+    TEXT = 0;
+    JSON = 1;
+    XML = 2;
+    HTML = 3;
+    BINARY = 4;
+}
+
+service WorkflowService {
+    rpc ExecuteWorkflow (WorkflowRequest) returns (WorkflowResponse) {}
+}

package/dist/scaffold-repo/triggers/grpc/src/GRpcTrigger.ts

@@ -0,0 +1,297 @@
+import {
+	DefaultLogger,
+	type GlobalOptions,
+	NodeMap,
+	type ParamsDictionary,
+	TriggerBase,
+	type TriggerResponse,
+} from "@blokjs/runner";
+import { type Context, GlobalError, type NodeBase } from "@blokjs/shared";
+import type { ConnectRouter } from "@connectrpc/connect";
+import { type Span, SpanStatusCode, metrics, trace } from "@opentelemetry/api";
+import fastify from "fastify";
+import { v4 as uuid } from "uuid";
+import MessageDecode from "./MessageDecode";
+import nodes from "./Nodes";
+import workflows from "./Workflows";
+import type RuntimeWorkflow from "./types/RuntimeWorkflow";
+
+import { workflow } from "@blokjs/helper";
+import type { TriggerOpts } from "@blokjs/helper";
+import {
+	MessageEncoding,
+	MessageType,
+	type WorkflowRequest,
+	type WorkflowResponse,
+	WorkflowService,
+} from "./gen/workflow_pb";
+
+enum NodeTypes {
+	MODULE = "module",
+	LOCAL = "local",
+	PYTHON3 = "runtime.python3",
+}
+
+export default class GRpcTrigger extends TriggerBase {
+	private server = fastify({
+		http2: true,
+		// https: {
+		//     key: readFileSync("localhost+2-key.pem", "utf8"),
+		//     cert: readFileSync("localhost+2.pem", "utf8"),
+		// }
+	});
+	private nodeMap: GlobalOptions = <GlobalOptions>{};
+	protected tracer = trace.getTracer(
+		process.env.PROJECT_NAME || "trigger-grpc-workflow",
+		process.env.PROJECT_VERSION || "0.0.1",
+	);
+	private logger = new DefaultLogger();
+	// Node/workflow maps injected by the host (e.g. a scaffolded project passing
+	// its own src/Nodes.ts + src/Workflows.ts). When omitted, the package's
+	// built-in Nodes/Workflows are used, so existing callers are unaffected.
+	private injectedNodes?: Record<string, unknown>;
+	private injectedWorkflows?: Record<string, unknown>;
+
+	constructor(injected?: { nodes?: Record<string, unknown>; workflows?: Record<string, unknown> }) {
+		super();
+		this.injectedNodes = injected?.nodes;
+		this.injectedWorkflows = injected?.workflows;
+		this.loadNodes();
+		this.loadWorkflows();
+	}
+
+	getApp() {
+		return this.server;
+	}
+
+	async listen(): Promise<number> {
+		return 0;
+	}
+
+	loadNodes() {
+		this.nodeMap.nodes = new NodeMap();
+		// Register each node under its own node.name (the canonical use: ref, ADR
+		// 0002) — the Nodes.ts map keys are cosmetic; the collision guard catches dups.
+		this.nodeMap.nodes.addNodes(Object.values(this.injectedNodes ?? nodes) as unknown as NodeBase[]);
+	}
+
+	loadWorkflows() {
+		this.nodeMap.workflows = (this.injectedWorkflows ?? workflows) as typeof workflows;
+	}
+
+	processRequest(router: ConnectRouter, trigger: GRpcTrigger) {
+		// F5/F6/F14 · gRPC boots via `GrpcServer.start()` → `processRequest`
+		// (its `listen()` is a no-op that returns 0). Run the shared boot
+		// setup here so a gRPC-only process gets crash/orphan/janitor/shutdown
+		// handlers, a populated WorkflowRegistry (subworkflow + middleware
+		// resolution), and `BLOK_GLOBAL_MIDDLEWARE` env seeding — parity with
+		// HTTP/Worker. All three helpers are idempotent.
+		trigger.installOperationalHandlers(trigger.logger);
+		trigger.registerWorkflowsFromNodeMap(trigger.logger);
+		trigger.seedGlobalMiddlewareFromEnv(trigger.logger);
+
+		router.service(WorkflowService, {
+			executeWorkflow: (request: WorkflowRequest) => trigger.executeWorkflow(request),
+		});
+	}
+
+	async executeWorkflow(request: WorkflowRequest) {
+		const start = performance.now();
+		const coder = new MessageDecode();
+		let name = request.Name;
+		const messageContext: Context = coder.requestDecode(request);
+		const runtimeWorkflow = messageContext as unknown as RuntimeWorkflow;
+		const id: string = (messageContext.request.query?.requestId as string) || (uuid() as string);
+		let remoteNodeExecution = false;
+
+		const defaultMeter = metrics.getMeter("default");
+		const workflow_runner_errors = defaultMeter.createCounter("workflow_errors", {
+			description: "Workflow runner errors",
+		});
+
+		return await this.tracer.startActiveSpan(`${name}`, async (span: Span) => {
+			try {
+				if (runtimeWorkflow !== undefined) {
+					const workflowModel = runtimeWorkflow.workflow;
+					const node_type = (workflowModel.steps[0] as unknown as ParamsDictionary).type;
+					let set_node_type: NodeTypes = NodeTypes.MODULE;
+					switch (node_type) {
+						case "runtime.python3":
+							set_node_type = NodeTypes.PYTHON3;
+							break;
+						case "local":
+							set_node_type = NodeTypes.LOCAL;
+							break;
+						default:
+							set_node_type = NodeTypes.MODULE;
+							break;
+					}
+
+					const trigger = Object.keys(workflowModel.trigger)[0];
+					const trigger_config =
+						((workflowModel.trigger as unknown as ParamsDictionary)[trigger] as unknown as TriggerOpts) || {};
+
+					const step = workflow({
+						name: `Remote Node: ${name}`,
+						version: "1.0.0",
+						description: "Remote Node",
+						trigger: { [(trigger as string) || "grpc"]: trigger_config },
+						steps: [
+							{
+								id: "node",
+								use: name,
+								type: set_node_type,
+								inputs: ((workflowModel.nodes as unknown as ParamsDictionary).node as unknown as ParamsDictionary)
+									.inputs,
+							},
+						],
+					} as unknown as Parameters<typeof workflow>[0]);
+
+					this.nodeMap.workflows[id] = step;
+					name = id;
+					remoteNodeExecution = true;
+				}
+
+				await this.configuration.init(name, this.nodeMap);
+				let ctx: Context = this.createContext(undefined, name, id);
+				ctx.request = messageContext.request;
+				ctx.logger.log(`Workflow: ${name}, Version: ${this.configuration.version}`);
+
+				// F1 · apply the merged middleware chain (process-global →
+				// workflow-level → trigger-level) before the main workflow
+				// body, after ctx.request is populated. A throwing middleware
+				// propagates to the outer catch (error encode). Pre-fix gRPC
+				// silently skipped ALL middleware — including auth gates.
+				await this.applyMiddlewareChain(ctx, this.nodeMap);
+
+				const response: TriggerResponse = await this.run(ctx);
+				ctx = response.ctx;
+				const average = response.metrics;
+
+				// Support both module nodes (wrapped BlokResponse with .data/.contentType)
+				// and runtime adapter nodes (raw data without wrapper)
+				const hasWrapper =
+					ctx.response && typeof ctx.response === "object" && "data" in ctx.response && "contentType" in ctx.response;
+				if (!hasWrapper) {
+					// Runtime adapter node: ctx.response is raw data, wrap it.
+					// The content-type comes from the SDK's proto `content_type`
+					// via the `_stepContentType` side-channel (set by
+					// RuntimeAdapterNode, reset per-step by RunnerSteps), so it
+					// travels alongside the body rather than inside it.
+					const resolvedContentType =
+						((ctx as Record<string, unknown>)._stepContentType as string | undefined) || "application/json";
+					ctx.response = {
+						data: ctx.response,
+						contentType: resolvedContentType,
+						success: true,
+						error: null,
+					} as typeof ctx.response;
+				}
+				if (ctx.response.contentType === undefined || ctx.response.contentType === "")
+					ctx.response.contentType = "application/json";
+
+				const end = performance.now();
+				ctx.logger.log(`Completed in ${(end - start).toFixed(2)}ms`);
+
+				span.setAttribute("success", true);
+				span.setAttribute("Content-Type", ctx.response.contentType as string);
+				span.setAttribute("workflow_request_id", `${ctx.id}`);
+				span.setAttribute("workflow_elapsed_time", `${end - start}`);
+				span.setAttribute("workflow_version", `${this.configuration.version}`);
+				span.setAttribute("workflow_name", `${this.configuration.name}`);
+				span.setAttribute("workflow_memory_avg_mb", `${average.memory.total}`);
+				span.setAttribute("workflow_memory_min_mb", `${average.memory.min}`);
+				span.setAttribute("workflow_memory_max_mb", `${average.memory.max}`);
+				span.setAttribute("workflow_cpu_percentage", `${average.cpu.average}`);
+				span.setAttribute("workflow_cpu_total", `${average.cpu.total}`);
+				span.setAttribute("workflow_cpu_usage", `${average.cpu.usage}`);
+				span.setAttribute("workflow_cpu_model", `${average.cpu.model}`);
+				span.setStatus({ code: SpanStatusCode.OK });
+
+				return coder.responseEncode(ctx, request.Encoding, request.Type);
+			} catch (e: unknown) {
+				span.setAttribute("success", false);
+				span.setAttribute("workflow_request_id", `${id}`);
+				span.recordException(e as Error);
+				let message: WorkflowResponse = <WorkflowResponse>{};
+				const base64Key = MessageEncoding[MessageEncoding.BASE64];
+				const textKey = MessageType[MessageType.TEXT];
+				const jsonKey = MessageType[MessageType.JSON];
+
+				if (e instanceof GlobalError) {
+					const error_context = e as GlobalError;
+
+					if (error_context.context.message === "{}" && error_context.context.json instanceof DOMException) {
+						workflow_runner_errors.add(1, {
+							env: process.env.NODE_ENV,
+							workflow_version: `${this.configuration.version || "unknown"}`,
+							workflow_name: `${name || this.configuration.name}`,
+						});
+						span.setStatus({
+							code: SpanStatusCode.ERROR,
+							message: (error_context.context.json as Error).toString(),
+						});
+
+						this.logger.error(`${(error_context.context.json as Error).toString()}`);
+						message = {
+							Message: coder.responseErrorEncode((error_context.context.json as Error).toString(), base64Key, textKey),
+							Encoding: base64Key,
+							Type: textKey,
+						} as WorkflowResponse;
+					} else {
+						if (error_context.context.code === undefined) error_context.setCode(500);
+
+						if (error_context.hasJson()) {
+							workflow_runner_errors.add(1, {
+								env: process.env.NODE_ENV,
+								workflow_version: `${this.configuration.version || "unknown"}`,
+								workflow_name: `${name || this.configuration.name}`,
+							});
+							span.setStatus({ code: SpanStatusCode.ERROR, message: JSON.stringify(error_context.context.json) });
+							this.logger.error(`${JSON.stringify(error_context.context.json)}`);
+							message = {
+								Message: coder.responseErrorEncode(JSON.stringify(error_context.context.json), base64Key, textKey),
+								Encoding: base64Key,
+								Type: jsonKey,
+							} as WorkflowResponse;
+						} else {
+							workflow_runner_errors.add(1, {
+								env: process.env.NODE_ENV,
+								workflow_version: `${this.configuration.version || "unknown"}`,
+								workflow_name: `${name || this.configuration.name}`,
+							});
+							span.setStatus({ code: SpanStatusCode.ERROR, message: error_context.message });
+							this.logger.error(`${error_context.message}`, error_context.stack?.replace(/\n/g, " "));
+							message = {
+								Message: coder.responseErrorEncode(error_context.message, base64Key, textKey),
+								Encoding: MessageEncoding[MessageEncoding.BASE64],
+								Type: textKey,
+							} as WorkflowResponse;
+						}
+					}
+				} else {
+					workflow_runner_errors.add(1, {
+						env: process.env.NODE_ENV,
+						workflow_version: `${this.configuration.version || "unknown"}`,
+						workflow_name: `${name || this.configuration.name}`,
+					});
+					span.setStatus({ code: SpanStatusCode.ERROR, message: (e as Error).message });
+					this.logger.error(`${(e as Error).message}`, `${(e as Error).stack?.replace(/\n/g, " ")}`);
+
+					message = {
+						Message: coder.responseErrorEncode((e as Error).message, base64Key, textKey),
+						Encoding: base64Key,
+						Type: textKey,
+					} as WorkflowResponse;
+				}
+
+				return message;
+			} finally {
+				if (remoteNodeExecution) {
+					delete this.nodeMap.workflows[id];
+				}
+				span.end();
+			}
+		});
+	}
+}