Reworked native and WIT cased naming for agent types and AgentID normalization (#2155)

* version: only match "v*" for git versions (so golem-rust and other release tags are not considered), and use fallback

* rework "bridging" between native and WIT cased names

* AgentID WAVE normalization

* WIP: use "native" types for RIB scripts, and "wit" types for instance creation

* Revert "WIP: use "native" types for RIB scripts, and "wit" types for instance creation"

This reverts commit adf84d8.

* rename wit arg types

* use WIT cased types for RIB everywhere

* cleanup and extend CLI test for complex agent names

* make fix

* make fix

* add agent types to component metadata

* use to_wit_naming instead of kebab in generators

* cleanup of AgentType naming

* more cleanups

* make fix

* fix invoke worker name

* clippy

* update golem ts agentic deps

Author: noise64

Cargo.lock

@@ -56,7 +56,7 @@ fn append_write_git_describe_tags_hook(file: &File) -> SdResult<()> {
 
 fn append_write_git_describe_tags(mut file: &File) -> SdResult<()> {
     let output = Command::new("git")
-        .args(["describe", "--tags", "--always"])
+        .args(["describe", "--tags", "--match", "v*", "--always"])
         .output()?;
 
     let version = {

cli/golem-cli/build.rs

@@ -172,19 +172,18 @@ impl ErrorHandler {
                     )
                     .await
                 {
-                    let agent_type = self
+                    let agent_id = self
                         .ctx
                         .worker_handler()
                         .validate_worker_and_function_names(
                             &component,
                             &worker_name_match.worker_name,
                             None,
-                        )
-                        .await?;
+                        )?;
 
                     log_text_view(&AvailableFunctionNamesHelp::new(
                         &component,
-                        agent_type.as_ref(),
+                        agent_id.as_ref(),
                     ));
                     logln("");
                 }

cli/golem-cli/src/command_handler/partial_match.rs

@@ -14,7 +14,7 @@
 
 use crate::command::shared_args::{DeployArgs, StreamArgs};
 use crate::command_handler::Handlers;
-use crate::context::Context;
+use crate::context::{Context, RibReplState};
 use crate::error::NonSuccessfulExit;
 use crate::fs;
 use crate::log::{logln, set_log_output, Output};
@@ -25,9 +25,10 @@ use crate::model::{
     ComponentName, ComponentNameMatchKind, ComponentVersionSelection, Format, IdempotencyKey,
     WorkerName,
 };
-use anyhow::bail;
+use anyhow::{anyhow, bail};
 use async_trait::async_trait;
 use colored::Colorize;
+use golem_common::model::agent::AgentId;
 use golem_rib_repl::{
     Command, CommandRegistry, ReplComponentDependencies, ReplContext, RibDependencyManager,
     RibRepl, RibReplConfig, WorkerFunctionInvoke,
@@ -122,23 +123,26 @@ impl RibReplHandler {
             .iter()
             .map(|agent_type| {
                 rib::CustomInstanceSpec::new(
-                    agent_type.type_name.to_string(),
+                    agent_type.wrapper_type_name(),
                     agent_type.constructor.wit_arg_types(),
                     Some(rib::InterfaceName {
-                        name: agent_type.type_name.to_string(),
+                        name: agent_type.wrapper_type_name(),
                         version: None,
                     }),
                 )
             })
             .collect::<Vec<_>>();
 
         self.ctx
-            .set_rib_repl_dependencies(ReplComponentDependencies {
-                component_dependencies: vec![ComponentDependency::new(
-                    component_dependency_key,
-                    component.metadata.exports().to_vec(),
-                )],
-                custom_instance_spec,
+            .set_rib_repl_state(RibReplState {
+                dependencies: ReplComponentDependencies {
+                    component_dependencies: vec![ComponentDependency::new(
+                        component_dependency_key,
+                        component.metadata.exports().to_vec(),
+                    )],
+                    custom_instance_spec,
+                },
+                component_metadata: component.metadata.clone(),
             })
             .await;
 
@@ -305,17 +309,21 @@ impl WorkerFunctionInvoke for RibReplHandler {
         args: Vec<ValueAndType>,
         _return_type: Option<AnalysedType>,
     ) -> anyhow::Result<Option<ValueAndType>> {
-        let worker_name = WorkerName::from(worker_name);
+        let worker_name: WorkerName = AgentId::parse(
+            worker_name,
+            &self.ctx.get_rib_repl_component_metadata().await,
+        )
+        .map_err(|err| anyhow!(err))?
+        .to_string()
+        .into();
 
         let component = self
             .ctx
             .component_handler()
             .component(
                 None,
                 component_id.into(),
-                Some(ComponentVersionSelection::ByWorkerName(&WorkerName(
-                    worker_name.to_string(),
-                ))),
+                Some(ComponentVersionSelection::ByWorkerName(&worker_name)),
             )
             .await?;
 

cli/golem-cli/src/command_handler/rib_repl.rs

@@ -51,8 +51,7 @@ use anyhow::{anyhow, bail};
 use colored::Colorize;
 use golem_client::api::{AgentTypesClient, ComponentClient, WorkerClient};
 use golem_client::model::{
-    AgentType, InvokeParameters as InvokeParametersCloud,
-    RevertLastInvocations as RevertLastInvocationsCloud,
+    InvokeParameters as InvokeParametersCloud, RevertLastInvocations as RevertLastInvocationsCloud,
     RevertToOplogIndex as RevertToOplogIndexCloud, RevertWorkerTarget as RevertWorkerTargetCloud,
     UpdateWorkerRequest as UpdateWorkerRequestCloud,
     WorkerCreationRequest as WorkerCreationRequestCloud,
@@ -207,8 +206,7 @@ impl WorkerCommandHandler {
             )
             .await?;
 
-        self.validate_worker_and_function_names(&component, &worker_name_match.worker_name, None)
-            .await?;
+        self.validate_worker_and_function_names(&component, &worker_name_match.worker_name, None)?;
 
         log_action(
             "Creating",
@@ -283,17 +281,19 @@ impl WorkerCommandHandler {
             )
             .await?;
 
-        // First validate without the function name
-        let agent_type = self
-            .validate_worker_and_function_names(&component, &worker_name_match.worker_name, None)
-            .await?;
+        // First, validate without the function name
+        let agent_id_and_type = self.validate_worker_and_function_names(
+            &component,
+            &worker_name_match.worker_name,
+            None,
+        )?;
 
         let matched_function_name = fuzzy_match_function_name(
             function_name,
             component.metadata.exports(),
-            agent_type
+            agent_id_and_type
                 .as_ref()
-                .and_then(|a| agent_interface_name(&component, &a.type_name))
+                .and_then(|a| agent_interface_name(&component, a.wrapper_agent_type()))
                 .as_deref(),
         );
         let function_name = match matched_function_name {
@@ -320,7 +320,7 @@ impl WorkerCommandHandler {
                     logln("");
                     log_text_view(&AvailableFunctionNamesHelp::new(
                         &component,
-                        agent_type.as_ref(),
+                        agent_id_and_type.as_ref(),
                     ));
 
                     bail!(NonSuccessfulExit);
@@ -334,21 +334,32 @@ impl WorkerCommandHandler {
                     logln("");
                     log_text_view(&AvailableFunctionNamesHelp::new(
                         &component,
-                        agent_type.as_ref(),
+                        agent_id_and_type.as_ref(),
                     ));
 
                     bail!(NonSuccessfulExit);
                 }
             },
         };
 
-        // Re-validate with function name
-        self.validate_worker_and_function_names(
+        // Re-validate with function-name
+        let agent_id = self.validate_worker_and_function_names(
             &component,
             &worker_name_match.worker_name,
             Some(&function_name),
-        )
-        .await?;
+        )?;
+
+        // Update worker_name with normalized agent id if needed
+        let worker_name_match = {
+            if let Some(agent_id) = agent_id {
+                WorkerNameMatch {
+                    worker_name: agent_id.to_string().into(),
+                    ..worker_name_match
+                }
+            } else {
+                worker_name_match
+            }
+        };
 
         if trigger {
             log_action(
@@ -1774,23 +1785,22 @@ impl WorkerCommandHandler {
         }
     }
 
-    pub async fn validate_worker_and_function_names(
+    pub fn validate_worker_and_function_names(
         &self,
         component: &Component,
         worker_name: &WorkerName,
         function_name: Option<&str>,
-    ) -> anyhow::Result<Option<AgentType>> {
+    ) -> anyhow::Result<Option<AgentId>> {
         if !component.metadata.is_agent() {
             return Ok(None);
         }
 
-        match AgentId::parse_and_resolve_type(&worker_name.0, &component.metadata).await {
-            Ok((agent_id, agent_type)) => match function_name {
+        match AgentId::parse(&worker_name.0, &component.metadata) {
+            Ok(agent_id) => match function_name {
                 Some(function_name) => {
                     if let Some((namespace, package, interface)) = component
                         .metadata
                         .find_function(function_name)
-                        .await
                         .ok()
                         .flatten()
                         .and_then(|f| match f.name.site {
@@ -1805,10 +1815,10 @@ impl WorkerCommandHandler {
                         })
                     {
                         let component_name = format!("{namespace}:{package}");
-                        if interface == agent_type.type_name
+                        if interface == agent_id.wrapper_agent_type()
                             && component.component_name.0 == component_name
                         {
-                            return Ok(Some(agent_type));
+                            return Ok(Some(agent_id));
                         }
                     }
 
@@ -1819,14 +1829,11 @@ impl WorkerCommandHandler {
                         function_name.log_color_error_highlight()
                     ));
                     logln("");
-                    log_text_view(&AvailableFunctionNamesHelp::new(
-                        component,
-                        Some(&agent_type),
-                    ));
+                    log_text_view(&AvailableFunctionNamesHelp::new(component, Some(&agent_id)));
                     bail!(NonSuccessfulExit);
                 }
 
-                None => Ok(Some(agent_type)),
+                None => Ok(Some(agent_id)),
             },
             Err(err) => {
                 logln("");

cli/golem-cli/src/command_handler/worker/mod.rs

@@ -50,6 +50,7 @@ use golem_client::api::WorkerClientLive as WorkerClientCloud;
 use golem_client::api::{AccountClient, AccountSummaryClientLive as AccountSummaryClientCloud};
 use golem_client::api::{AccountClientLive as AccountClientCloud, LoginClientLive};
 use golem_client::{Context as ContextCloud, Security};
+use golem_common::model::component_metadata::ComponentMetadata;
 use golem_rib_repl::ReplComponentDependencies;
 use golem_templates::model::{ComposableAppGroupName, GuestLanguage};
 use golem_templates::ComposableAppTemplate;
@@ -468,9 +469,9 @@ impl Context {
         Ok(app_ctx.application.task_result_marker_dir())
     }
 
-    pub async fn set_rib_repl_dependencies(&self, dependencies: ReplComponentDependencies) {
+    pub async fn set_rib_repl_state(&self, state: RibReplState) {
         let mut rib_repl_state = self.rib_repl_state.write().await;
-        rib_repl_state.dependencies = dependencies;
+        *rib_repl_state = state;
     }
 
     pub async fn get_rib_repl_dependencies(&self) -> ReplComponentDependencies {
@@ -481,6 +482,11 @@ impl Context {
         }
     }
 
+    pub async fn get_rib_repl_component_metadata(&self) -> ComponentMetadata {
+        let rib_repl_state = self.rib_repl_state.read().await;
+        rib_repl_state.component_metadata.clone()
+    }
+
     pub fn templates(
         &self,
         dev_mode: bool,
@@ -861,7 +867,8 @@ impl ApplicationContextState {
 }
 
 pub struct RibReplState {
-    dependencies: ReplComponentDependencies,
+    pub dependencies: ReplComponentDependencies,
+    pub component_metadata: ComponentMetadata,
 }
 
 impl Default for RibReplState {
@@ -871,6 +878,7 @@ impl Default for RibReplState {
                 component_dependencies: vec![],
                 custom_instance_spec: vec![],
             },
+            component_metadata: ComponentMetadata::default(),
         }
     }
 }

cli/golem-cli/src/context.rs

@@ -16,8 +16,9 @@ use crate::model::agent::wit::AgentWrapperGeneratorContext;
 use anyhow::{anyhow, Context};
 use camino::Utf8Path;
 use golem_client::model::AnalysedType;
+use golem_common::model::agent::wit_naming::ToWitNaming;
 use golem_common::model::agent::{AgentType, DataSchema, ElementSchema, NamedElementSchemas};
-use heck::{ToKebabCase, ToLowerCamelCase, ToShoutySnakeCase, ToSnakeCase, ToUpperCamelCase};
+use heck::{ToLowerCamelCase, ToShoutySnakeCase, ToSnakeCase, ToUpperCamelCase};
 use moonbit_component_generator::{
     to_moonbit_ident, MoonBitComponent, MoonBitPackage, Warning, WarningControl,
 };
@@ -846,7 +847,7 @@ fn build_data_value(
             for named_element_schema in elements {
                 let case_name = named_element_schema
                     .name
-                    .to_kebab_case()
+                    .to_wit_naming()
                     .to_upper_camel_case();
                 writeln!(
                     result,
@@ -894,7 +895,7 @@ fn write_builder(
             writeln!(result, "{indent}  match {access} {{")?;
 
             for (case_idx, case) in variant.cases.iter().enumerate() {
-                let case_name = case.name.to_kebab_case().to_upper_camel_case();
+                let case_name = case.name.to_wit_naming().to_upper_camel_case();
                 match &case.typ {
                     Some(_) => {
                         writeln!(
@@ -915,7 +916,7 @@ fn write_builder(
             writeln!(result, "{indent}  match {access} {{")?;
 
             for case in &variant.cases {
-                let case_name = case.name.to_kebab_case().to_upper_camel_case();
+                let case_name = case.name.to_wit_naming().to_upper_camel_case();
                 match &case.typ {
                     Some(_) => {
                         writeln!(
@@ -1202,7 +1203,7 @@ fn extract_data_value(
             writeln!(result, "{indent}values.map(pair => {{")?;
             writeln!(result, "{indent}  match pair.0 {{")?;
             for element in elements {
-                let case_name = element.name.to_kebab_case().to_upper_camel_case();
+                let case_name = element.name.to_wit_naming().to_upper_camel_case();
                 writeln!(result, "{indent}    \"{}\" => {{", element.name)?;
                 match &element.schema {
                     ElementSchema::ComponentModel(schema) => {
@@ -1279,7 +1280,7 @@ fn extract_wit_value(
             writeln!(result, "{indent}  match idx {{")?;
 
             for (idx, case) in variant.cases.iter().enumerate() {
-                let case_name = case.name.to_kebab_case().to_upper_camel_case();
+                let case_name = case.name.to_wit_naming().to_upper_camel_case();
 
                 writeln!(result, "{indent}    {idx} => {{")?;
                 if let Some(inner_type) = &case.typ {