@mondaydotcomorg/atp-runtime 0.17.16 → 0.18.2

package/src/metadata/index.ts

@@ -4,16 +4,72 @@
 
 export type { RuntimeAPIParam, RuntimeAPIMethod, RuntimeAPIMetadata } from './types.js';
 export { RuntimeAPI, RuntimeMethod } from './decorators.js';
+export type { RuntimeAPIName } from './generated.js';
 
 import type { RuntimeAPIMetadata } from './types.js';
+import type { RuntimeAPIName } from './generated.js';
+import { TYPE_REGISTRY } from './generated.js';
+
+interface ClientServices {
+	hasLLM: boolean;
+	hasApproval: boolean;
+	hasEmbedding: boolean;
+	hasTools: boolean;
+}
 
 /**
  * Generates TypeScript definitions from runtime API metadata
+ * @param apis - Runtime API metadata
+ * @param options - Optional filtering options
  */
-export function generateRuntimeTypes(apis: RuntimeAPIMetadata[]): string {
-	let typescript = '// Runtime SDK\ndeclare const atp: {\n';
+export function generateRuntimeTypes(
+	apis: RuntimeAPIMetadata[],
+	options?: {
+		clientServices?: ClientServices;
+		requestedApis?: RuntimeAPIName[];
+	}
+): string {
+	let filteredApis = apis;
+
+	if (options?.requestedApis && options.requestedApis.length > 0) {
+		const requestedApis = options.requestedApis.map((api) => apis.find((a) => a.name === api));
+		filteredApis = requestedApis.filter((api) => api !== undefined);
+	} else if (options?.clientServices) {
+		filteredApis = apis.filter((api) => {
+			if (api.name === 'llm' && !options.clientServices!.hasLLM) return false;
+			if (api.name === 'approval' && !options.clientServices!.hasApproval) return false;
+			if (api.name === 'embedding' && !options.clientServices!.hasEmbedding) return false;
+			if (api.name === 'progress') return false;
+			return true;
+		});
+	} else {
+		filteredApis = apis.filter((api) => api.name === 'cache');
+	}
+
+	let typescript = '// Runtime SDK Type Definitions\n\n';
+
+	const usedTypes = new Set<string>();
+	for (const api of filteredApis) {
+		for (const method of api.methods) {
+			const allTypes = [method.returns, ...method.params.map((p) => p.type)].join(' ');
+			const typeMatches = allTypes.match(/\b[A-Z][a-zA-Z]+\b/g);
+			if (typeMatches) {
+				typeMatches.forEach((t) => usedTypes.add(t));
+			}
+		}
+	}
+
+	for (const type of TYPE_REGISTRY) {
+		const typeNameMatch = type.definition.match(/(?:interface|type)\s+([A-Z][a-zA-Z]+)/);
+		const typeName = typeNameMatch?.[1];
+		if (typeName && usedTypes.has(typeName)) {
+			typescript += `${type.definition}\n\n`;
+		}
+	}
+
+	typescript += '// Runtime SDK\ndeclare const atp: {\n';
 
-	for (const api of apis) {
+	for (const api of filteredApis) {
 		typescript += `  /**\n`;
 		for (const line of api.description.split('\n')) {
 			typescript += `   * ${line}\n`;

package/src/metadata/types.ts

@@ -3,6 +3,8 @@
  * Each runtime module exports its metadata for the type generator
  */
 
+import { RuntimeAPIName } from './generated';
+
 export interface RuntimeAPIParam {
 	name: string;
 	type: string;
@@ -18,7 +20,7 @@ export interface RuntimeAPIMethod {
 }
 
 export interface RuntimeAPIMetadata {
-	name: string;
+	name: RuntimeAPIName;
 	description: string;
 	methods: RuntimeAPIMethod[];
 }