agent-config: update ts sdk to expose agent config

Author: mschuwalow

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

@@ -19,9 +19,11 @@ import {
   AgentMode,
   Principal,
   Snapshotting,
+  ConfigKeyValueType,
+  ConfigValueType,
 } from 'golem:agent/common';
 import { ResolvedAgent } from '../internal/resolvedAgent';
-import { TypeMetadata } from '@golemcloud/golem-ts-types-core';
+import { ConstructorArg, TypeMetadata } from '@golemcloud/golem-ts-types-core';
 import {
   getNewPhantomRemoteClient,
   getPhantomRemoteClient,
@@ -42,6 +44,8 @@ import { validateHttpMount } from '../internal/http/validation';
 import { getAgentConstructorSchema } from '../internal/schema/constructor';
 import { getAgentMethodSchema } from '../internal/schema/method';
 import ms from 'ms';
+import { fromTsType } from '../internal/mapping/types/WitType';
+import { TypeScope } from '../internal/mapping/types/scope';
 
 export type SnapshottingOption = 'disabled' | 'enabled' | { periodic: string } | { every: number };
 
@@ -281,6 +285,11 @@ export function agent(options?: AgentDecoratorOptions) {
       validateHttpMount(agentClassName.value, httpMount, constructor);
     }
 
+    const agentConfigEntries = Either.getOrThrowWith(
+      getAgentConfigEntries(classMetadata.constructorArgs),
+      err => new Error(`Failed to describe agent config: ${err}`),
+    );
+
     const agentType: AgentType = {
       typeName: agentTypeName.value,
       description: agentTypeDescription,
@@ -290,7 +299,7 @@ export function agent(options?: AgentDecoratorOptions) {
       mode: options?.mode ?? 'durable',
       httpMount,
       snapshotting: resolveSnapshotting(options?.snapshotting),
-      config: [],
+      config: agentConfigEntries,
     };
 
     AgentTypeRegistry.register(agentClassName, agentType);
@@ -370,3 +379,31 @@ export function agent(options?: AgentDecoratorOptions) {
     });
   };
 }
+
+function getAgentConfigEntries(constructorParameters: ConstructorArg[]): Either.Either<ConfigKeyValueType[], string> {
+  const entries: ConfigKeyValueType[] = [];
+
+  for (const param of constructorParameters) {
+    if (param.type.kind !== 'config') continue;
+
+    for (const prop of param.type.properties) {
+
+      const witTypeEither = fromTsType(prop.type, TypeScope.object(param.name, prop.path[-1], prop.type.optional));
+      if (Either.isLeft(witTypeEither)) return witTypeEither;
+
+      let configValueType: ConfigValueType;
+      if (prop.secret) {
+        configValueType = { tag: 'shared', val: witTypeEither.val[0] }
+      } else {
+        configValueType = { tag: 'local', val: witTypeEither.val[0] }
+      }
+
+      entries.push({
+        key: prop.path,
+        value: configValueType,
+      });
+    }
+  }
+
+    return Either.right(entries);
+}

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

@@ -20,6 +20,8 @@ import { AgentTypeRegistry } from './internal/registry/agentTypeRegistry';
 import { AgentInitiatorRegistry } from './internal/registry/agentInitiatorRegistry';
 import { getRawSelfAgentId } from './host/hostapi';
 import { AgentInitiator } from './internal/agentInitiator';
+import { TypeInfoInternal } from './internal/typeInfoInternal';
+import { loadConfigKey } from './internal/mapping/values/dataValue';
 
 export { BaseAgent } from './baseAgent';
 export { AgentId } from './agentId';
@@ -229,3 +231,26 @@ export const saveSnapshot: typeof bindings.saveSnapshot = {
 export const loadSnapshot: typeof bindings.loadSnapshot = {
   load,
 };
+
+export class Secret<T> {
+  private readonly path: string[];
+  private readonly typeInfoInternal: TypeInfoInternal;
+
+  constructor(path: string[], typeInfoInternal: TypeInfoInternal) {
+    this.path = path;
+    this.typeInfoInternal = typeInfoInternal;
+  }
+
+  /** Lazily loads or reloads the secret value */
+  get(): T {
+    return loadConfigKey(this.path, this.typeInfoInternal);
+  }
+}
+
+export class Config<T> {
+  readonly value: T;
+
+  constructor(value: T) {
+    this.value = value;
+  }
+}

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

@@ -443,6 +443,11 @@ function convertToValue(
         'Internal error: Value of `Principal` should not be serialized at any point during RPC call',
       );
 
+    case 'config':
+      return Either.left(
+        'Internal error: Value of `Config` should not be serialized at any point during RPC call',
+      );
+
     case 'multimodal':
       const types = typeInfoInternal.types;
 
@@ -653,6 +658,9 @@ function convertNonMultimodalValueToElementValue(
     case 'principal':
       throw new Error(`Internal error: Value of 'Principal' should not appear in RPC calls`);
 
+    case 'config':
+      throw new Error(`Internal error: Value of 'Config' should not appear in RPC calls`);
+
     case 'unstructured-binary':
       const binaryReference = convertValueToBinaryReference(rpcValueUnwrapped);
 

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

@@ -67,6 +67,7 @@ const handlers: { [K in TsType['kind']]: Handler<K> } = {
   others: handleOthers,
   'unresolved-type': handleUnresolved,
   array: handleArray,
+  'config': unsupported('Config')
 };
 
 function unsupported(kind: string): Handler<any> {

sdks/ts/packages/golem-ts-sdk/src/internal/mapping/values/dataValue.ts

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 import {
+  isConfig,
   isEmptyType,
   isOptionalWithQuestionMark,
   isPrincipal,
@@ -39,6 +40,9 @@ import * as util from 'node:util';
 
 import * as Value from '../values/Value';
 import { getLanguageCodes, getMimeTypes } from '../../schema/helpers';
+import { Config, Secret } from '../../..';
+import { Type } from '@golemcloud/golem-ts-types-core';
+import { getConfigValue } from 'golem:agent/host';
 
 export type ParameterDetail = {
   name: string;
@@ -73,7 +77,7 @@ export function deserializeDataValue(
       const inputElementsLen = inputElements.length;
 
       // An index that's incremented corresponding to the schema
-      // The index is incremented for each type unless it is of type `Principal`
+      // The index is incremented for each type unless it is autoinjected
       let schemaBasedIndex = 0;
 
       return Either.all(
@@ -93,6 +97,10 @@ export function deserializeDataValue(
               return Either.right(principal);
             }
 
+            if (isConfig(parameterType)) {
+              return Either.right(constructConfigType(parameterType));
+            }
+
             throw new Error(
               `Internal error: Not enough elements in data value to deserialize parameter ${parameterDetail.name}`,
             );
@@ -107,10 +115,15 @@ export function deserializeDataValue(
               );
 
             case 'principal':
-              // If principal, we do not increment the data value elemnt index,
+              // If principal, we do not increment the data value element index,
               // because principal is not represented in data value
               return Either.right(principal);
 
+            case 'config':
+              // If config, we do not increment the data value element index,
+              // because config is not represented in data value
+              return Either.right(constructConfigType(parameterType));
+
             case 'unstructured-text':
               const unstructuredTextParamName = parameterDetail.name;
 
@@ -293,6 +306,66 @@ export function deserializeDataValue(
   }
 }
 
+function constructConfigType(
+  typeInfoInternal: TypeInfoInternal & { tag: 'config' }
+): Config<any> {
+  // safe as the parent node is config
+  const properties = (typeInfoInternal.tsType as (Type.Type & { kind: 'config' })).properties;
+
+  const root: Record<string, any> = {};
+
+  for (const prop of properties) {
+    const { path } = prop;
+    if (!path.length) continue;
+
+    let current = root;
+
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (!(key in current)) current[key] = {};
+      current = current[key];
+    }
+
+    const leafKey = path[path.length - 1];
+    let leafValue;
+    if (prop.secret) {
+      leafValue = new Secret(path, typeInfoInternal)
+    } else {
+      leafValue = loadConfigKey(path, typeInfoInternal);
+    }
+
+    current[leafKey] = leafValue;
+  }
+
+  return new Config(root);
+}
+
+export function loadConfigKey(
+  path: string[],
+  typeInfoInternal: TypeInfoInternal
+): any {
+  const witValue = getConfigValue(path);
+
+  const dataValue = createSingleElementTupleDataValue({
+    tag: 'component-model',
+    val: witValue,
+  });
+
+  return Either.getOrThrowWith(
+    deserializeDataValue(
+      dataValue,
+      [
+        {
+          name: 'config-type',
+          type: typeInfoInternal
+        }
+      ],
+      { tag: 'anonymous' },
+    ),
+    (err) => new Error(`Failed to deserialize config: ${err}`),
+  )
+}
+
 // Used to serialize the return type of a method back to DataValue
 export function serializeToDataValue(
   tsValue: any,
@@ -324,6 +397,11 @@ export function serializeToDataValue(
         `Internal Error: Serialization of 'Principal' data should have never happened`,
       );
 
+    case 'config':
+      return Either.left(
+        `Internal Error: Serialization of 'Config' data should have never happened`,
+      );
+
     case 'unstructured-text':
       return Either.right(serializeTextReferenceToDataValue(tsValue));
 

sdks/ts/packages/golem-ts-sdk/src/internal/schema/constructor.ts

@@ -74,6 +74,19 @@ const principalHandler: ConstructorParamHandler = {
   },
 };
 
+const configHandler: ConstructorParamHandler = {
+  canHandle: (param) => param.type.kind === 'config',
+
+  handle: (agentClassName, param, _, collection) => {
+    AgentConstructorParamRegistry.setType(agentClassName, param.name, {
+      tag: 'config',
+      tsType: param.type,
+    });
+
+    collection.addConfigParameter(param.name);
+  },
+};
+
 const unstructuredTextHandler: ConstructorParamHandler = {
   canHandle: (param) => param.type.name === 'UnstructuredText',
 
@@ -155,6 +168,7 @@ const analysedHandler: ConstructorParamHandler = {
 
 const HANDLERS: readonly ConstructorParamHandler[] = [
   principalHandler,
+  configHandler,
   unstructuredTextHandler,
   unstructuredBinaryHandler,
   analysedHandler,

sdks/ts/packages/golem-ts-sdk/src/internal/schema/paramSchema.ts

@@ -24,6 +24,10 @@ export class ParameterSchemaCollection {
     this.parameterSchemas.push({ tag: 'principal', name });
   }
 
+  addConfigParameter(name: string): void {
+    this.parameterSchemas.push({ tag: 'config', name });
+  }
+
   addComponentModelParameter(name: string, schema: ElementSchema): void {
     this.parameterSchemas.push({
       tag: 'component-model',
@@ -39,18 +43,22 @@ export class ParameterSchemaCollection {
 
 export type ParameterSchema =
   | { tag: 'principal'; name: string }
+  | { tag: 'config'; name: string }
   | { tag: 'component-model'; name: string; schema: ElementSchema };
 
 // Remove principal parameters
 function getDataSchema(parameterSchemaCollection: ParameterSchema[]): DataSchema {
   let nameAndSchema: [string, ElementSchema][] = [];
 
   for (const paramSchema of parameterSchemaCollection) {
-    if (paramSchema.tag === 'principal') {
-    }
-
-    if (paramSchema.tag === 'component-model') {
-      nameAndSchema.push([paramSchema.name, paramSchema.schema]);
+    switch (paramSchema.tag) {
+      case 'config':
+        break;
+      case 'principal':
+        break;
+      case 'component-model':
+        nameAndSchema.push([paramSchema.name, paramSchema.schema]);
+        break;
     }
   }
   return {

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

@@ -34,6 +34,7 @@ export type TypeInfoInternal =
   | { tag: 'unstructured-text'; val: TextDescriptor; tsType: Type.Type }
   | { tag: 'unstructured-binary'; val: BinaryDescriptor; tsType: Type.Type }
   | { tag: 'principal'; tsType: Type.Type }
+  | { tag: 'config'; tsType: Type.Type }
   | {
       tag: 'multimodal';
       types: ParameterDetail[];
@@ -54,6 +55,10 @@ export function isPrincipal(typeInfoInternal: TypeInfoInternal): boolean {
   return typeInfoInternal.tag === 'principal';
 }
 
+export function isConfig(typeInfoInternal: TypeInfoInternal): typeInfoInternal is (TypeInfoInternal & { tag: 'config'}) {
+  return typeInfoInternal.tag === 'config';
+}
+
 export function isEmptyType(typeInfoInternal: TypeInfoInternal): boolean {
   if (typeInfoInternal.tag === 'analysed') {
     const analysed = typeInfoInternal.val;
@@ -87,6 +92,8 @@ export function convertTypeInfoToElementSchema(
       });
     case 'principal':
       return Either.left('Cannot convert `Principal` type information to ElementSchema');
+    case 'config':
+      return Either.left('Cannot convert `Principal` type information to ElementSchema');
     case 'multimodal':
       return Either.left('Cannot convert multimodal type information to ElementSchema');
   }
@@ -110,6 +117,8 @@ export function getMultimodalDataSchemaFromTypeInternal(
       return Either.left('cannot get multimodal DataSchema from unstructured-binary type info');
     case 'principal':
       return Either.left('cannot get multimodal DataSchema from principal type info');
+    case 'config':
+      return Either.left('cannot get multimodal DataSchema from config type info');
     case 'multimodal':
       const parameterDetails = typeInfoInternal.types;
 
@@ -191,6 +200,8 @@ export function getReturnTypeDataSchemaFromTypeInternal(
       });
     case 'principal':
       return Either.left('Principal cannot be used as a method return type');
+    case 'config':
+      return Either.left('Config cannot be used as a method return type');
     case 'multimodal':
       return getMultimodalDataSchemaFromTypeInternal(typeInfoInternal);
   }