Update to tucana 0.0.66, implement function definitions

.github/workflows/build.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Set up Node
         uses: actions/setup-node@v6
         with:
-          node-version: '24.x'
+          node-version: '25.9.x'
           registry-url: 'https://registry.npmjs.org'
       - name: Install dependencies
         run: npm ci

.github/workflows/publish.yml

@@ -24,7 +24,7 @@ jobs:
       - name: Set up Node
         uses: actions/setup-node@v6
         with:
-          node-version: '24.x'
+          node-version: '25.9.x'
           registry-url: 'https://registry.npmjs.org'
       - name: Install dependencies
         run: npm ci

mise.toml

@@ -1,2 +1,3 @@
 [tools]
+node = "25.9.0"
 ruby = "latest"

ts/.tool-versions

@@ -1 +1 @@
-node 24.8.0
+nodejs 25.9.0

ts/examples/simple-example-ts/index.ts

@@ -6,9 +6,9 @@ import {
 } from "@code0-tech/hercules";
 
 const sdk = createSdk({
-    authToken: "someToken",
+    authToken: "token",
     aquilaUrl: "127.0.0.1:50051",
-    actionId: "action_123",
+    actionId: "service",
     version: "0.0.0",
 }, [
     {

ts/package.json

@@ -30,7 +30,7 @@
   "license": "ISC",
   "type": "module",
   "dependencies": {
-    "@code0-tech/tucana": "^0.0.65",
+    "@code0-tech/tucana": "^0.0.66",
     "@grpc/grpc-js": "^1.14.3",
     "@protobuf-ts/grpc-backend": "^2.11.1",
     "@protobuf-ts/grpc-transport": "^2.11.1",

ts/src/action_sdk.ts

@@ -10,7 +10,9 @@ import {
     DataTypeServiceClient,
     DataTypeUpdateRequest, ExecutionRequest,
     FlowTypeServiceClient,
-    FlowTypeUpdateRequest, RuntimeFunctionDefinitionServiceClient, RuntimeFunctionDefinitionUpdateRequest,
+    FlowTypeUpdateRequest,
+    FunctionDefinitionServiceClient,
+    FunctionDefinitionUpdateRequest, RuntimeFunctionDefinitionServiceClient, RuntimeFunctionDefinitionUpdateRequest,
     TransferRequest, TransferResponse
 } from "@code0-tech/tucana/aquila";
 import {
@@ -30,6 +32,7 @@ const createSdk = (config: ActionSdk["config"], configDefinitions?: HerculesActi
 
     const state: SdkState = {
         functions: [],
+        runtimeFunctions: [],
         dataTypes: [],
         flowTypes: [],
         configurationDefinitions: configDefinitions?.map(value => {
@@ -137,11 +140,11 @@ const createSdk = (config: ActionSdk["config"], configDefinitions?: HerculesActi
             })
             return Promise.resolve()
         },
-        registerFunctionDefinitions: async (...functionDefinitions) => {
-            for (const registeredFunction of functionDefinitions) {
+        registerRuntimeFunctionDefinitions: async (...runtimeFunctionDefinitions) => {
+            for (const registeredFunction of runtimeFunctionDefinitions) {
                 const handler = registeredFunction.handler;
                 const functionDefinition = registeredFunction.definition;
-                state.functions.push({
+                state.runtimeFunctions.push({
                     identifier: functionDefinition.runtimeName,
                     definition: {
                         displayMessage: functionDefinition.displayMessage || [],
@@ -170,6 +173,36 @@ const createSdk = (config: ActionSdk["config"], configDefinitions?: HerculesActi
             }
             return Promise.resolve()
         },
+        registerFunctionDefinitions: async (...functionDefinitions) => {
+            for (const functionDefinition of functionDefinitions) {
+                state.functions.push({
+                    identifier: functionDefinition.runtimeName,
+                    definition: {
+                        displayMessage: functionDefinition.displayMessage || [],
+                        name: functionDefinition.name || [],
+                        documentation: functionDefinition.documentation || [],
+                        description: functionDefinition.description || [],
+                        deprecationMessage: functionDefinition.deprecationMessage || [],
+                        displayIcon: functionDefinition.displayIcon || "",
+                        alias: functionDefinition.alias || [],
+                        linkedDataTypeIdentifiers: functionDefinition.linkedDataTypes || [],
+                        definitionSource: "action",
+                        version: functionDefinition.version || config.version,
+                        runtimeName: functionDefinition.runtimeName,
+                        parameterDefinitions: (functionDefinition.parameters || []).map(param => ({
+                            runtimeName: param.runtimeName,
+                            name: param.name || [],
+                            description: param.description || [],
+                            documentation: param.documentation || [],
+                            defaultValue: constructValue(param.defaultValue || null),
+                        })),
+                        signature: functionDefinition.signature,
+                        throwsError: functionDefinition.throwsError || false,
+                    }
+                });
+            }
+            return Promise.resolve()
+        },
         dispatchEvent: async (eventType, projectId, payload) => {
             if (!state.stream) {
                 return Promise.reject("SDK is not connected. Call connect() before dispatching events.");
@@ -242,6 +275,23 @@ async function connect(state: SdkState, config: ActionSdk["config"], options?: R
         RuntimeFunctionDefinitionUpdateRequest.create(
             {
                 runtimeFunctions: [
+                    ...state.runtimeFunctions.map(func => ({
+                        ...func.definition,
+                    }))
+                ]
+            }
+        ), builtOptions
+    ).then(value => {
+        if (!value.response.success) {
+            return Promise.reject(value.response);
+        }
+    })
+
+    const FunctionDefinitionClient = new FunctionDefinitionServiceClient(state.transport)
+    await FunctionDefinitionClient.update(
+        FunctionDefinitionUpdateRequest.create(
+            {
+                functions: [
                     ...state.functions.map(func => ({
                         ...func.definition,
                     }))
@@ -309,7 +359,7 @@ function handleExecutionRequest(state: SdkState, message: TransferResponse) {
         return
     }
     const execution = message.data.execution as ExecutionRequest;
-    const func = state.functions.find(value => value.identifier == execution.functionIdentifier);
+    const func = state.runtimeFunctions.find(value => value.identifier == execution.functionIdentifier);
     if (func) {
         const params = Object.entries(execution.parameters!.fields!).map(([key, value]) => {
             const param = func.definition.runtimeParameterDefinitions

ts/src/types.ts

@@ -4,7 +4,7 @@ import {
     ActionConfigurationDefinition, ActionProjectConfiguration,
     DefinitionDataType,
     DefinitionDataTypeRule, FlowType,
-    FlowTypeSetting_UniquenessScope,
+    FlowTypeSetting_UniquenessScope, FunctionDefinition,
     RuntimeFunctionDefinition,
     Translation
 } from "@code0-tech/tucana/shared";
@@ -56,6 +56,7 @@ export interface HerculesFlowType {
     displayIcon?: string,
 }
 
+
 export interface HerculesRuntimeFunctionDefinition {
     runtimeName: string,
     parameters?: {
@@ -78,6 +79,8 @@ export interface HerculesRuntimeFunctionDefinition {
     displayIcon?: string,
 }
 
+export type HerculesRegisterFunctionDefinition = HerculesRuntimeFunctionDefinition
+
 export interface HerculesActionProjectConfiguration {
     projectId: number | bigint,
     configValues: {
@@ -96,7 +99,7 @@ export interface HerculesActionConfigurationDefinition {
     identifier: string,
 }
 
-export type HerculesRegisterFunctionParameter = {
+export type HerculesRegisterRuntimeFunctionParameter = {
     definition: HerculesRuntimeFunctionDefinition,
     handler: (...args: any[]) => Promise<PlainValue> | PlainValue,
 }
@@ -117,7 +120,8 @@ export interface ActionSdk {
     registerConfigDefinitions: (...actionConfigurations: Array<HerculesActionConfigurationDefinition>) => Promise<void>,
     registerDataTypes: (...dataType: Array<HerculesDataType>) => Promise<void>,
     registerFlowTypes: (...flowTypes: Array<HerculesFlowType>) => Promise<void>,
-    registerFunctionDefinitions: (...functionDefinitions: Array<HerculesRegisterFunctionParameter>) => Promise<void>,
+    registerFunctionDefinitions: (...functionDefinitions: Array<HerculesRegisterFunctionDefinition>) => Promise<void>,
+    registerRuntimeFunctionDefinitions: (...runtimeFunctionDefinitions: Array<HerculesRegisterRuntimeFunctionParameter>) => Promise<void>,
     dispatchEvent: (eventType: string, projectId: number | bigint, payload: PlainValue) => Promise<void>,
 }
 
@@ -134,13 +138,19 @@ export class RuntimeErrorException extends Error {
 }
 
 export interface RegisteredFunction {
+    identifier: string,
+    definition: FunctionDefinition
+}
+
+export interface RegisteredRuntimeFunction {
     identifier: string,
     definition: RuntimeFunctionDefinition,
     handler: (...args: any[]) => Promise<PlainValue> | PlainValue,
 }
 
 export interface SdkState {
     functions: RegisteredFunction[],
+    runtimeFunctions: RegisteredRuntimeFunction[],
     dataTypes: DefinitionDataType[],
     flowTypes: FlowType[],
     configurationDefinitions: ActionConfigurationDefinition[],