sdks/ts: replace any with proper types in SDK core

Replace `any` types with `unknown`, generics, and proper type
constraints across the SDK. Uses Reflect.construct for safe
instantiation, Object.assign for typed function objects, and
generic wrappers for deserialize functions.

Author: Myestery

sdks/ts/packages/golem-ts-sdk/src/baseAgent.ts

@@ -102,11 +102,11 @@ export class BaseAgent {
    */
   async loadSnapshot(bytes: Uint8Array): Promise<void> {
     const text = new TextDecoder().decode(bytes);
-    const state = JSON.parse(text);
+    const state = JSON.parse(text) as Partial<this>;
 
     for (const [k, v] of Object.entries(state)) {
       if (k === 'cachedAgentType' || k === 'agentClassName') continue;
-      (this as any)[k] = v;
+      this[k as keyof this] = v;
     }
   }
 
@@ -220,15 +220,17 @@ export class BaseAgent {
  *
  * ```
  */
+type MethodKeys<T> = {
+  [K in keyof T]-?: T[K] extends (...args: never[]) => unknown ? K : never;
+}[keyof T];
+
 export type Client<T> = {
-  [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: T[K] extends (
-    ...args: infer A
-  ) => infer R
+  [K in MethodKeys<T>]: T[K] extends (...args: infer A) => infer R
     ? RemoteMethod<GetArgs<A>, Awaited<R>>
     : never;
 };
 
-export type RemoteMethod<Args extends any[], R> = {
+export type RemoteMethod<Args extends unknown[], R> = {
   (...args: Args): Promise<R>;
   trigger: (...args: Args) => void;
   schedule: (ts: Datetime, ...args: Args) => void;
@@ -254,8 +256,8 @@ type GetArgs<T extends readonly unknown[]> =
 type IsOptional<T extends readonly unknown[], K extends keyof T> =
   {} extends Pick<T, K> ? true : false;
 
-type AllOptional<T extends readonly unknown[], I extends any[] = []> = T extends readonly [
-  any,
+type AllOptional<T extends readonly unknown[], I extends unknown[] = []> = T extends readonly [
+  unknown,
   ...infer R,
 ]
   ? IsOptional<T, I['length']> extends true

sdks/ts/packages/golem-ts-sdk/src/decorators/agent.ts

@@ -60,6 +60,12 @@ export type AgentDecoratorOptions = {
   phantom?: boolean;
 };
 
+type MutableAgentStatics = {
+  get?: unknown;
+  newPhantom?: unknown;
+  getPhantom?: unknown;
+};
+
 function parseDurationToNanoseconds(duration: string): bigint {
   const milliseconds = ms(duration as ms.StringValue);
   if (milliseconds === undefined) {
@@ -325,10 +331,10 @@ export function agent(options?: AgentDecoratorOptions) {
       );
     }
 
-    (ctor as any).get = getRemoteClient(agentClassName, agentType, ctor);
-    (ctor as any).newPhantom = getNewPhantomRemoteClient(agentClassName, agentType, ctor);
-
-    (ctor as any).getPhantom = getPhantomRemoteClient(agentClassName, agentType, ctor);
+    const decoratedCtor = ctor as T & MutableAgentStatics;
+    decoratedCtor.get = getRemoteClient(agentClassName, agentType, ctor);
+    decoratedCtor.newPhantom = getNewPhantomRemoteClient(agentClassName, agentType, ctor);
+    decoratedCtor.getPhantom = getPhantomRemoteClient(agentClassName, agentType, ctor);
 
     AgentInitiatorRegistry.register(agentTypeName, {
       initiate: (constructorInput: DataValue, principal: Principal) => {
@@ -349,7 +355,7 @@ export function agent(options?: AgentDecoratorOptions) {
           };
         }
 
-        const instance = new ctor(...deserializedConstructorArgs.val);
+        const instance = Reflect.construct(ctor, deserializedConstructorArgs.val) as BaseAgent;
 
         const agentId = getRawSelfAgentId();
         if (!agentId.value.startsWith(agentTypeName.value)) {

sdks/ts/packages/golem-ts-sdk/src/host/result.ts

@@ -316,25 +316,25 @@ function flatten<T, E, E2>(this: Result<Result<T, E>, E2>): Result<T, E | E2> {
   else return this.val;
 }
 
-function assertErrorInstanceOf<T, C extends abstract new (..._: any) => any>(
+function assertErrorInstanceOf<T, C extends abstract new (..._: unknown[]) => unknown>(
   this: Result.Ok<T>,
   constructor: C,
 ): Result.Ok<T>;
-function assertErrorInstanceOf<E, C extends abstract new (..._: any) => any>(
+function assertErrorInstanceOf<E, C extends abstract new (..._: unknown[]) => unknown>(
   this: Result.Err<E>,
   constructor: C,
 ): Result.Err<E & InstanceType<C>>;
-function assertErrorInstanceOf<T, E, C extends abstract new (..._: any) => any>(
+function assertErrorInstanceOf<T, E, C extends abstract new (..._: unknown[]) => unknown>(
   this: Result<T, E>,
   constructor: C,
 ): Result<T, E & InstanceType<C>>;
-function assertErrorInstanceOf<T, E, C extends abstract new (..._: any) => any>(
+function assertErrorInstanceOf<T, E, C extends abstract new (..._: unknown[]) => unknown>(
   this: Result<T, E>,
   constructor: C,
 ): Result<T, E & InstanceType<C>> {
   if (this.isOk()) return this;
 
-  if (this.val instanceof constructor) return this as any;
+  if (this.val instanceof constructor) return this as Result<T, E & InstanceType<C>>;
 
   throw new TypeError(`Assertion failed: Expected error to be an instance of ${constructor.name}.`);
 }

sdks/ts/packages/golem-ts-sdk/src/host/transaction.ts

@@ -233,6 +233,6 @@ export function fallibleTransaction<Out, Err>(
  * ```
  *
  */
-export type OperationErrors<T extends Operation<any, any, any>[]> = {
-  [K in keyof T]: T[K] extends Operation<any, any, infer Err> ? Err : never;
+export type OperationErrors<T extends Operation<unknown, unknown, unknown>[]> = {
+  [K in keyof T]: T[K] extends Operation<unknown, unknown, infer Err> ? Err : never;
 }[number];

sdks/ts/packages/golem-ts-sdk/src/internal/clientGeneration.ts

@@ -31,7 +31,7 @@ import {
   ElementValue,
   TextReference,
 } from 'golem:agent/common@1.5.0';
-import { RemoteMethod } from '../baseAgent';
+import { BaseAgent, RemoteMethod } from '../baseAgent';
 import { AgentMethodParamRegistry } from './registry/agentMethodParamRegistry';
 import { AgentConstructorParamRegistry } from './registry/agentConstructorParamRegistry';
 import { AgentMethodRegistry } from './registry/agentMethodRegistry';
@@ -40,19 +40,20 @@ import {
   serializeTsValueToTextReference,
 } from './mapping/values/serializer';
 import { TypeInfoInternal } from './typeInfoInternal';
-import {
-  deserializeDataValue,
-  ParameterDetail,
-  serializeToDataValue,
-} from './mapping/values/dataValue';
+import { deserializeDataValue, serializeToDataValue } from './mapping/values/dataValue';
 import { randomUuid } from '../host/hostapi';
 import { AgentId } from '../agentId';
 import * as util from 'node:util';
 
-export function getRemoteClient<T extends new (...args: any[]) => any>(
+type AgentClass<T extends BaseAgent = BaseAgent> = {
+  readonly name: string;
+  readonly prototype: T;
+};
+
+export function getRemoteClient(
   agentClassName: AgentClassName,
   agentType: AgentType,
-  ctor: T,
+  ctor: AgentClass,
 ) {
   const metadata = TypeMetadata.get(ctor.name);
 
@@ -63,7 +64,7 @@ export function getRemoteClient<T extends new (...args: any[]) => any>(
   }
   const shared = new WasmRpxProxyHandlerShared(metadata, agentClassName, agentType);
 
-  return (...args: any[]) => {
+  return (...args: unknown[]) => {
     const instance = Object.create(ctor.prototype);
 
     const constructedId = shared.constructAgentId(args);
@@ -72,10 +73,10 @@ export function getRemoteClient<T extends new (...args: any[]) => any>(
   };
 }
 
-export function getPhantomRemoteClient<T extends new (phantomId: Uuid, ...args: any[]) => any>(
+export function getPhantomRemoteClient(
   agentClassName: AgentClassName,
   agentType: AgentType,
-  ctor: T,
+  ctor: AgentClass,
 ) {
   const metadata = TypeMetadata.get(ctor.name);
 
@@ -87,7 +88,7 @@ export function getPhantomRemoteClient<T extends new (phantomId: Uuid, ...args:
 
   const shared = new WasmRpxProxyHandlerShared(metadata, agentClassName, agentType);
 
-  return (finalPhantomId: Uuid, ...args: any[]) => {
+  return (finalPhantomId: Uuid, ...args: unknown[]) => {
     const instance = Object.create(ctor.prototype);
 
     const constructedId = shared.constructAgentId(args, finalPhantomId);
@@ -96,10 +97,10 @@ export function getPhantomRemoteClient<T extends new (phantomId: Uuid, ...args:
   };
 }
 
-export function getNewPhantomRemoteClient<T extends new (...args: any[]) => any>(
+export function getNewPhantomRemoteClient(
   agentClassName: AgentClassName,
   agentType: AgentType,
-  ctor: T,
+  ctor: AgentClass,
 ) {
   const metadata = TypeMetadata.get(ctor.name);
 
@@ -110,7 +111,7 @@ export function getNewPhantomRemoteClient<T extends new (...args: any[]) => any>
   }
   const shared = new WasmRpxProxyHandlerShared(metadata, agentClassName, agentType);
 
-  return (...args: any[]) => {
+  return (...args: unknown[]) => {
     const instance = Object.create(ctor.prototype);
 
     const finalPhantomId = randomUuid();
@@ -166,7 +167,7 @@ class WasmRpxProxyHandlerShared {
     }
   }
 
-  constructAgentId(args: any[], phantomId?: Uuid): ConstructedAgentId {
+  constructAgentId(args: unknown[], phantomId?: Uuid): ConstructedAgentId {
     let constructorDataValue: DataValue;
 
     if (args.length === 1 && this.constructorParamTypes[0].tag === 'multimodal') {
@@ -289,12 +290,12 @@ class WasmRpxProxyHandlerShared {
   }
 }
 
-class WasmRpcProxyHandler implements ProxyHandler<any> {
+class WasmRpcProxyHandler implements ProxyHandler<Record<string, unknown>> {
   private readonly shared: WasmRpxProxyHandlerShared;
   private readonly agentId: AgentId;
   private readonly wasmRpc: WasmRpc;
 
-  private readonly methodProxyCache = new Map<string, RemoteMethod<any[], any>>();
+  private readonly methodProxyCache = new Map<string, RemoteMethod<unknown[], unknown>>();
 
   private readonly getIdMethod: () => AgentId = () => this.agentId;
   private readonly phantomIdMethod: () => Uuid | undefined = () => {
@@ -314,8 +315,8 @@ class WasmRpcProxyHandler implements ProxyHandler<any> {
     );
   }
 
-  get(target: any, prop: string | symbol) {
-    const val = target[prop];
+  get(target: Record<string, unknown>, prop: string | symbol) {
+    const val = target[prop.toString()];
     const propString = prop.toString();
 
     if (typeof val === 'function') {
@@ -349,12 +350,12 @@ class WasmRpcProxyHandler implements ProxyHandler<any> {
     return undefined;
   }
 
-  private createMethodProxy(prop: string): RemoteMethod<any[], any> {
+  private createMethodProxy(prop: string): RemoteMethod<unknown[], unknown> {
     const methodInfo = this.shared.getMethodInfo(prop);
     const agentIdString = this.agentId.value;
     const wasmRpc = this.wasmRpc;
 
-    async function invokeAndAwait(...fnArgs: any[]) {
+    async function invokeAndAwait(...fnArgs: unknown[]) {
       const inputDataValue = serializeArgs(methodInfo.params, fnArgs);
 
       const rpcResultFuture = wasmRpc.asyncInvokeAndAwait(methodInfo.name, inputDataValue);
@@ -383,26 +384,29 @@ class WasmRpcProxyHandler implements ProxyHandler<any> {
       return deserializeRpcResult(resultDataValue, methodInfo.returnType);
     }
 
-    function invokeFireAndForget(...fnArgs: any[]) {
+    function invokeFireAndForget(...fnArgs: unknown[]) {
       const inputDataValue = serializeArgs(methodInfo.params, fnArgs);
       wasmRpc.invoke(methodInfo.name, inputDataValue);
     }
 
-    function invokeSchedule(ts: Datetime, ...fnArgs: any[]) {
+    function invokeSchedule(ts: Datetime, ...fnArgs: unknown[]) {
       const inputDataValue = serializeArgs(methodInfo.params, fnArgs);
       wasmRpc.scheduleInvocation(ts, methodInfo.name, inputDataValue);
     }
 
-    const methodFn: any = (...args: any[]) => invokeAndAwait(...args);
-
-    methodFn.trigger = (...args: any[]) => invokeFireAndForget(...args);
-    methodFn.schedule = (ts: Datetime, ...args: any[]) => invokeSchedule(ts, ...args);
+    const methodFn: RemoteMethod<unknown[], unknown> = Object.assign(
+      (...args: unknown[]) => invokeAndAwait(...args),
+      {
+        trigger: (...args: unknown[]) => invokeFireAndForget(...args),
+        schedule: (ts: Datetime, ...args: unknown[]) => invokeSchedule(ts, ...args),
+      },
+    );
 
-    return methodFn as RemoteMethod<any[], any>;
+    return methodFn;
   }
 }
 
-function serializeArgs(params: CachedParamInfo[], fnArgs: any[]): DataValue {
+function serializeArgs(params: CachedParamInfo[], fnArgs: unknown[]): DataValue {
   const elementValues: ElementValue[] = [];
   for (const [index, fnArg] of fnArgs.entries()) {
     const param = params[index];
@@ -441,14 +445,8 @@ function serializeArgs(params: CachedParamInfo[], fnArgs: any[]): DataValue {
             `Failed to serialize multimodal arg ${param.name}: ${dataValueEither.val}`,
           );
         }
-        // For a multimodal param, the serialized DataValue is itself the result;
-        // we wrap it as a single tuple with the multimodal elements
         const multimodalDv = dataValueEither.val;
         if (multimodalDv.tag === 'multimodal') {
-          // Each multimodal element becomes part of the overall DataValue
-          // But since params are tuple-based, we need to wrap multimodal as a single element
-          // The server expects each param as an ElementValue in the tuple
-          // For multimodal, we serialize the whole thing as a component-model WitValue
           for (const [, ev] of multimodalDv.val) {
             elementValues.push(ev);
           }
@@ -464,7 +462,10 @@ function serializeArgs(params: CachedParamInfo[], fnArgs: any[]): DataValue {
   return { tag: 'tuple', val: elementValues };
 }
 
-function deserializeRpcResult(resultDataValue: DataValue, typeInfoInternal: TypeInfoInternal): any {
+function deserializeRpcResult<T = unknown>(
+  resultDataValue: DataValue,
+  typeInfoInternal: TypeInfoInternal,
+): T {
   return Either.getOrThrowWith(
     deserializeDataValue(
       resultDataValue,
@@ -477,5 +478,5 @@ function deserializeRpcResult(resultDataValue: DataValue, typeInfoInternal: Type
       { tag: 'anonymous' },
     ),
     (err) => new Error(`Failed to deserialize return value of RPC call: ${err}`),
-  )[0];
+  )[0] as T;
 }

sdks/ts/packages/golem-ts-sdk/src/internal/mapping/types/handlers.ts

@@ -70,7 +70,7 @@ const handlers: { [K in TsType['kind']]: Handler<K> } = {
   config: unsupported('Config'),
 };
 
-function unsupported(kind: string): Handler<any> {
+function unsupported<K extends TsType['kind']>(kind: string): Handler<K> {
   return ({ scopeName, parameterInScope }) =>
     Either.left(
       `Unsupported type \`${kind}\`` +
@@ -79,7 +79,7 @@ function unsupported(kind: string): Handler<any> {
     );
 }
 
-function unsupportedWithHint(kind: string, hint: string): Handler<any> {
+function unsupportedWithHint<K extends TsType['kind']>(kind: string, hint: string): Handler<K> {
   return ({ scopeName, parameterInScope }) =>
     Either.left(
       `Unsupported type \`${kind}\`${scopeName ? ` in ${scopeName}` : ''}` +

sdks/ts/packages/golem-ts-sdk/src/internal/mapping/types/witTypeBuilder.ts

@@ -49,6 +49,7 @@ export class WitTypeBuilder {
   }
 
   private convert(typ: AnalysedType): WitTypeNode {
+    let kind = typ.kind;
     switch (typ.kind) {
       case 'variant': {
         const cases: [string, NodeIndex | undefined][] = typ.value.cases.map(
@@ -127,7 +128,7 @@ export class WitTypeBuilder {
       }
 
       default:
-        throw new Error(`Unhandled AnalysedType kind: ${(typ as any).kind}`);
+        throw new Error(`Unhandled AnalysedType kind: ${kind}`);
     }
   }
 }