feat: migrate workspace configuration domains to ServerApi

crates/worker/src/feature/builtin/memory.rs

@@ -104,7 +104,7 @@ async fn execute_memory_backend(
     let response = client.execute(WorkspaceRequest::json(
         WorkspaceRequestMethod::Post,
         format!("/api/w/{workspace_id}/memory/backend"),
-        serde_json::to_string(&operation)?,
+        serde_json::to_string(&server_api::MemoryBackendRequest(operation))?,
     ))?;
     let status = reqwest::StatusCode::from_u16(response.status)
         .unwrap_or(reqwest::StatusCode::INTERNAL_SERVER_ERROR);
@@ -114,7 +114,7 @@ async fn execute_memory_backend(
             body: response.body,
         });
     }
-    match serde_json::from_str::<MemoryBackendHttpResponse>(&response.body)? {
+    match serde_json::from_str::<server_api::MemoryBackendResponse>(&response.body)?.0 {
         MemoryBackendHttpResponse::Ok { result } => Ok(result),
         MemoryBackendHttpResponse::Error { message } => {
             Err(WorkspaceMemoryBackendError::Backend(message))
@@ -138,7 +138,9 @@ async fn execute_memory_consolidation(
     let response = client.execute(WorkspaceRequest::json(
         WorkspaceRequestMethod::Post,
         format!("/api/w/{workspace_id}/memory/consolidation"),
-        serde_json::to_string(&operation)?,
+        serde_json::to_string(&server_api::MemoryConsolidateStagingRequest {
+            force: operation.force,
+        })?,
     ))?;
     let status = reqwest::StatusCode::from_u16(response.status)
         .unwrap_or(reqwest::StatusCode::INTERNAL_SERVER_ERROR);
@@ -148,7 +150,13 @@ async fn execute_memory_consolidation(
             body: response.body,
         });
     }
-    serde_json::from_str::<MemoryConsolidationOutput>(&response.body).map_err(Into::into)
+    let response = serde_json::from_str::<server_api::MemoryConsolidationResponse>(&response.body)?;
+    Ok(MemoryConsolidationOutput {
+        status: response.status,
+        summary: response.summary,
+        candidate_count: response.candidate_count,
+        total_bytes: response.total_bytes,
+    })
 }
 
 pub fn workspace_http_memory_tools(client: Arc<dyn WorkspaceClient>) -> Vec<ToolDefinition> {

crates/worker/src/skill.rs

@@ -1,23 +1,13 @@
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 
 use crate::worker::WorkspaceClient;
 
 pub use server_api::{
-    SkillActivationStatus, SkillCatalogEntry, SkillCatalogResponse, SkillDetailResponse,
-    SkillDiagnostic, SkillDiagnosticSeverity, SkillProjectionIdentity, SkillProjectionStatus,
-    SkillProvenance, SkillResourceRef, SkillSourceKind,
+    SkillActivationResponse, SkillActivationStatus, SkillCatalogEntry, SkillCatalogResponse,
+    SkillDetailResponse, SkillDiagnostic, SkillDiagnosticSeverity, SkillProjectionIdentity,
+    SkillProjectionStatus, SkillProvenance, SkillResourceRef, SkillSourceKind,
 };
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct SkillActivationResponse {
-    pub name: String,
-    pub provenance: SkillProvenance,
-    #[serde(default)]
-    pub diagnostics: Vec<SkillDiagnostic>,
-    /// Imported Markdown content to append to Worker history on explicit activation.
-    pub body: String,
-}
-
 #[derive(Debug, thiserror::Error)]
 pub enum SkillClientError {
     #[error("workspace client is unavailable: {0}")]

crates/worker/src/worker.rs

@@ -3889,8 +3889,8 @@ impl<C: LlmClient + 'static, St: Store> Worker<C, St> {
             .ok_or_else(|| {
                 WorkerError::FlowInput("Workspace client has no Workspace scope".to_string())
             })?;
-        let request = flow::FlowSourceResolveRequest {
-            selector: selector.clone(),
+        let request = server_api::FlowSourceResolveRequest {
+            selector: selector.to_string(),
         };
         let response = workspace
             .execute(WorkspaceRequest {
@@ -3915,13 +3915,19 @@ impl<C: LlmClient + 'static, St: Store> Worker<C, St> {
                 response.status
             )));
         }
-        let source: flow::ResolvedFlowSource = serde_json::from_str(&response.body)
+        let wire_source: server_api::ResolvedFlowSource = serde_json::from_str(&response.body)
             .map_err(|error| WorkerError::FlowInput(format!("decode Flow source: {error}")))?;
-        if source.workspace_id != workspace_id || source.selector != selector {
+        if wire_source.workspace_id != workspace_id || wire_source.selector != selector.to_string()
+        {
             return Err(WorkerError::FlowInput(
                 "Workspace returned a Flow source outside the requested scope".to_string(),
             ));
         }
+        let source: flow::ResolvedFlowSource =
+            serde_json::from_value(serde_json::to_value(wire_source).map_err(|error| {
+                WorkerError::FlowInput(format!("project Flow source transport: {error}"))
+            })?)
+            .map_err(|error| WorkerError::FlowInput(format!("convert Flow source: {error}")))?;
         let (state, initial_instructions) =
             flow::FlowRuntimeState::start(&source, uuid::Uuid::now_v7().to_string())
                 .map_err(|error| WorkerError::FlowInput(error.to_string()))?;