WIP: AI Action

actions/ai-action/.example.env

@@ -0,0 +1,4 @@
+HERCULES_AUTH_TOKEN=your_hercules_auth_token_here
+HERCULES_AQUILA_URL=https://aquila.hercules-ci.com
+HERCULES_ACTION_ID=gls-action
+HERCULES_SDK_VERSION=0.0.0

actions/ai-action/Dockerfile

@@ -0,0 +1,18 @@
+FROM node:24-alpine
+
+WORKDIR /app
+
+COPY code0-tech-* ./
+
+COPY package.json package-lock.json tsconfig.base.json turbo.json ./
+
+COPY actions/ai ./actions/ai-action
+
+RUN npm ci
+
+WORKDIR /app/actions/ai-action
+
+RUN npm run build
+
+
+CMD ["npm", "run", "start", "-w", "@code0-tech/ai-action"]

actions/ai-action/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@code0-tech/ai-action",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "vite build",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "start": "node dist/main.js",
+    "generate:docs": "npm run build && node dist/generateDocs.js"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.66",
+    "@ai-sdk/google": "^3.0.57",
+    "@ai-sdk/mcp": "^1.0.32",
+    "@ai-sdk/openai": "^3.0.50",
+    "ai": "^6.0.146",
+    "ai-sdk-ollama": "^3.8.2",
+    "ollama-ai-provider-v2": "^3.5.0",
+    "ts-morph": "^27.0.2"
+  }
+}

actions/ai-action/scripts/generateDocs.ts

@@ -0,0 +1,48 @@
+import {runStandardActionDocs, StandardActionDocsConfig} from "../../../src/standardActionDocs"
+import {loadAllDefinitions, loadAllDefinitionsByModules} from "../src/helpers";
+
+export function generateAIConfig(): StandardActionDocsConfig {
+    return {
+        actionName: "AI",
+        typePrefix: "AI_",
+        typesOutputPath: "../../docs/Actions/AI/types.mdx",
+        functionsOutputPath: "../../docs/Actions/AI/functions.mdx",
+        loadAllDefinitions: loadAllDefinitions,
+        typeLinkOverrides: {},
+        typesCopy: {
+            title: "Datatypes",
+            description: "All data types registered by the AI Action.",
+            heading: "AI Action Types",
+            intro: `The AI Action registers the following data types with the Hercules platform.`,
+        },
+        functionsCopy: {
+            title: "Functions",
+            description: "All functions registered by the AI Action.",
+            intro: ""
+        },
+        functionGroups: [
+            {
+                heading: "OpenAI Models",
+                loadFunctions: async (sdk) => await loadAllDefinitionsByModules(sdk, import.meta.glob("../src/functions/models/openai/common.ts")),
+            },
+            {
+                heading: "Google Models",
+                loadFunctions: async (sdk) => await loadAllDefinitionsByModules(sdk, import.meta.glob("../src/functions/models/google/common.ts")),
+            },
+            {
+                heading: "Anthropic Models",
+                loadFunctions: async (sdk) => await loadAllDefinitionsByModules(sdk, import.meta.glob("../src/functions/models/anthropic/common.ts")),
+            },
+            {
+                heading: "Ollama",
+                loadFunctions: async (sdk) => await loadAllDefinitionsByModules(sdk, import.meta.glob("../src/functions/models/ollama/common.ts")),
+            },
+            {
+                heading: "Tools",
+                loadFunctions: async (sdk) => await loadAllDefinitionsByModules(sdk, import.meta.glob("../src/functions/tools/**/*.ts")),
+            }
+        ],
+    }
+}
+
+await runStandardActionDocs(generateAIConfig())

actions/ai-action/src/config/modelAuthConfig.ts

@@ -0,0 +1,36 @@
+import {ActionSdk} from "@code0-tech/hercules";
+import {z} from "zod";
+import {singleZodSchemaToTypescriptDef} from "../../../../src/helpers"
+import {ModelSchema} from "../types/aiModel";
+
+const providers = ModelSchema.shape.provider.options;
+
+export const ModelAuthConfigSchema = z.object(
+    Object.fromEntries(
+        providers.map((option) => [
+            option,
+            z.object({
+                authToken: z.string(),
+            })
+        ])
+    )
+);
+
+export default (sdk: ActionSdk) => {
+    sdk.registerDataTypes({
+        type: singleZodSchemaToTypescriptDef("AI_MODEL_AUTH_CONFIG", ModelAuthConfigSchema),
+        identifier: "AI_MODEL_AUTH_CONFIG"
+    })
+
+    return sdk.registerConfigDefinitions({
+        type: "AI_MODEL_AUTH_CONFIG",
+        identifier: "MODEL_AUTH",
+        linkedDataTypes: ["AI_MODEL_AUTH_CONFIG"],
+        name: [
+            {
+                code: "en-US",
+                content: "Model auth"
+            }
+        ]
+    })
+}

actions/ai-action/src/config/toolsAuthConfig.ts

@@ -0,0 +1,36 @@
+import {ActionSdk} from "@code0-tech/hercules";
+import {singleZodSchemaToTypescriptDef} from "../../../../src/helpers";
+import {z} from "zod";
+import {ToolProviderEnum} from "../types/aiTool";
+
+const providers = ToolProviderEnum.options;
+
+export const ToolsAuthConfigSchema = z.object(
+    Object.fromEntries(
+        providers.map((option) => [
+            option,
+            z.object({
+                authToken: z.string(),
+            })
+        ])
+    )
+);
+
+export default (sdk: ActionSdk) => {
+    sdk.registerDataTypes({
+        type: singleZodSchemaToTypescriptDef("AI_TOOLS_AUTH_CONFIG", ToolsAuthConfigSchema),
+        identifier: "AI_TOOLS_AUTH_CONFIG"
+    })
+
+    return sdk.registerConfigDefinitions({
+        type: "AI_TOOLS_AUTH_CONFIG",
+        identifier: "TOOLS_AUTH",
+        linkedDataTypes: ["AI_TOOLS_AUTH_CONFIG"],
+        name: [
+            {
+                code: "en-US",
+                content: "Model auth"
+            }
+        ]
+    })
+}

actions/ai-action/src/functions/generateStructuredData.ts

@@ -0,0 +1,139 @@
+import {ActionSdk, HerculesFunctionContext} from "@code0-tech/hercules";
+import {Model} from "../types/aiModel";
+import {Tool} from "../types/aiTool";
+import {extractToken} from "../helpers";
+import {generateText, isLoopFinished, Output} from "ai";
+import {PlainValue} from "@code0-tech/tucana/helpers";
+import {buildProvider, buildTools} from "./helpers";
+import z from "zod";
+
+
+function generateZodSchema(value: PlainValue): z.ZodTypeAny {
+    if (value === null) {
+        return z.null();
+    }
+
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return z.array(z.unknown());
+        }
+
+        const itemSchemas = value.map((item) => generateZodSchema(item));
+        const itemSchema =
+            itemSchemas.length === 1
+                ? itemSchemas[0]
+                : itemSchemas.slice(1).reduce((acc, current) => z.union([acc, current]), itemSchemas[0]);
+
+        return z.array(itemSchema);
+    }
+
+    switch (typeof value) {
+        case "string":
+            return z.string();
+        case "number":
+            return z.number();
+        case "boolean":
+            return z.boolean();
+        case "object": {
+            const shape: Record<string, z.ZodTypeAny> = {};
+            for (const [key, nestedValue] of Object.entries(value as Record<string, PlainValue>)) {
+                shape[key] = generateZodSchema(nestedValue);
+            }
+            return z.object(shape);
+        }
+        default:
+            return z.unknown();
+    }
+}
+
+export const handler = async (context: HerculesFunctionContext, model: Model, system: string, prompt: string, tools: Tool[], type: PlainValue): Promise<PlainValue> => {
+    const apiKey = extractToken(context, model.provider)
+
+    const provider = buildProvider(model, apiKey);
+
+    const modelTools = await buildTools(tools, context);
+
+    const generated = await generateText({
+        model: provider.languageModel(model.model),
+        prompt: prompt,
+        system: system,
+        tools: modelTools,
+        stopWhen: isLoopFinished(),
+        output: Output.object({
+            schema: generateZodSchema(type)
+        })
+    })
+
+    return generated.output as any
+};
+export default (sdk: ActionSdk) => {
+    return sdk.registerRuntimeFunctionDefinitionsAndFunctionDefinitions(
+        {
+            definition: {
+                runtimeName: "generateStructuredData",
+                signature: "(model: AI_MODEL, system: string, prompt: string, tools: AI_TOOL[], type: TYPE): TYPE",
+                linkedDataTypes: ["AI_MODEL", "AI_TOOL", "TYPE"],
+                name: [
+                    {
+                        code: "en-US",
+                        content: "Generate structured Data"
+                    }
+                ],
+                displayMessage: [
+                    {
+                        code: "en-US",
+                        content: "generate structured Data"
+                    }
+                ],
+                parameters: [
+                    {
+                        runtimeName: "model",
+                        name: [
+                            {
+                                code: "en-US",
+                                content: "Model"
+                            }
+                        ],
+                    },
+                    {
+                        runtimeName: "system",
+                        name: [
+                            {
+                                code: "en-US",
+                                content: "System prompt"
+                            }
+                        ]
+                    },
+                    {
+                        runtimeName: "prompt",
+                        name: [
+                            {
+                                code: "en-US",
+                                content: "Prompt"
+                            }
+                        ]
+                    },
+                    {
+                        runtimeName: "tools",
+                        name: [
+                            {
+                                code: "en-US",
+                                content: "Tools"
+                            }
+                        ]
+                    },
+                    {
+                        runtimeName: "type",
+                        name: [
+                            {
+                                code: "en-US",
+                                content: "Output Type"
+                            }
+                        ]
+                    }
+                ]
+            },
+            handler: handler
+        }
+    )
+}

actions/ai-action/src/functions/generateText.ts

@@ -0,0 +1,38 @@
+import {ActionSdk, HerculesFunctionContext} from "@code0-tech/hercules";
+import {Model} from "../types/aiModel";
+import {extractToken} from "../helpers";
+import {generateText, isLoopFinished} from "ai";
+import {Tool} from "../types/aiTool";
+import {buildProvider, buildTools} from "./helpers";
+
+
+export const handler = async (context: HerculesFunctionContext, model: Model, system: string, prompt: string, tools: Tool[]): Promise<string> => {
+    const apiKey = extractToken(context, model.provider)
+
+    const provider = buildProvider(model, apiKey);
+
+    const modelTools = await buildTools(tools, context);
+
+    const generated = await generateText({
+        model: provider.languageModel(model.model),
+        prompt: prompt,
+        system: system,
+        tools: modelTools,
+        stopWhen: isLoopFinished(),
+    })
+
+    return generated.output
+};
+
+export default (sdk: ActionSdk) => {
+    return sdk.registerRuntimeFunctionDefinitionsAndFunctionDefinitions(
+        {
+            definition: {
+                runtimeName: "generateText",
+                signature: "(model: AI_MODEL, system: string, prompt: string, tools: AI_TOOL[]): string",
+                linkedDataTypes: ["AI_MODEL", "AI_TOOL"]
+            },
+            handler: handler
+        }
+    )
+}