object

package
v1.785.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 19, 2026 License: Apache-2.0 Imports: 101 Imported by: 0

Documentation

Overview

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2024 The Hanzo Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2025 The Hanzo Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2025 The Hanzo Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2025 The Casibase Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2024 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2023-2026 Hanzo AI Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Package object/zap.go — Native ZAP binary protocol node.

Cloud-api is a first-class ZAP node. NO gateways, NO proxies, NO sidecars, NO HTTP translation layers. Everything is ZAP-to-ZAP: 

client → cloud-api:9999 (ZAP binary)
cloud-api → kv:9999     (ZAP binary)
cloud-api → sql:9999    (ZAP binary)

Service handlers are registered via RegisterCloudHandler() from the controllers package (avoids circular imports).

Index

Constants

View Source 
const (
	StatusNotDeployed = "Not Deployed"
	StatusPending     = string(v1.PodPending) // "Pending"
	StatusRunning     = string(v1.PodRunning) // "Running"
	StatusUnknown     = string(v1.PodUnknown) // "Unknown"
	StatusFailed      = string(v1.PodFailed)
	StatusTerminating = "Terminating"
	NamespaceFormat   = "hanzo-cloud-%s"
)
View Source 
const (
	NoConnect    = "no_connect"
	Connecting   = "connecting"
	Connected    = "connected"
	Disconnected = "disconnected"
)
View Source 
const (
	ScaleStatePublic = "Public"
	ScaleStateHidden = "Hidden"
)

Scale state values for visibility (which scales are included in public lists).

View Source 
const (
	// Cloud service — native binary RPC, NO HTTP.
	MsgTypeCloud uint16 = 100
	// Gateway → cloud-api (HTTP-over-ZAP from gateway proxy).
	// Request:  method(0:Text) + path(8:Text) + headers(16:Bytes) + body(24:Bytes) + query(32:Text)
	// Response: status(0:Uint32) + body(4:Bytes) + headers(12:Bytes)
	MsgTypeHTTPRequest uint16 = 200
	// Backend sidecar protocol (KV/SQL embedded servers).
	MsgTypeSQL       uint16 = 300
	MsgTypeKV        uint16 = 301
	MsgTypeDatastore uint16 = 302
	MsgTypeDocdb     uint16 = 303
	// ── Cloud service message layout ────────────────────────────────
	// Request:  method(0:Text) + auth(8:Text) + body(16:Bytes)
	// Response: status(0:Uint32) + body(4:Bytes) + error(12:Text)
	CloudReqMethod  = 0
	CloudReqAuth    = 8
	CloudReqBody    = 16
	CloudRespStatus = 0
	CloudRespBody   = 4
	CloudRespError  = 12
)

── Message types ───────────────────────────────────────────────────────

Cloud service types (100-199): 

100 = Cloud service request (method dispatch)

Backend types (300-399, matches sidecar protocol): 

300 = SQL query/exec
301 = KV get/set/cmd

Variables

View Source 
var (
	// ApiThroughput uses *prometheus.GaugeVec directly because Reset() is needed
	ApiThroughput = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name: "cloud_api_throughput",
		Help: "The throughput of each api access",
	}, []string{"path", "method"})
	ApiLatency = promauto.NewHistogramVec(prometheus.HistogramOpts{
		Name: "cloud_api_latency",
		Help: "API processing latency in milliseconds",
	}, []string{"path", "method"})
	CpuUsage = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name: "cloud_cpu_usage",
		Help: "Hanzo Cloud cpu usage",
	}, []string{"cpuNum"})
	MemoryUsage = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name: "cloud_memory_usage",
		Help: "Hanzo Cloud memory usage in Byte",
	}, []string{"type"})
	TotalThroughput = promauto.NewGauge(prometheus.GaugeOpts{
		Name: "cloud_total_throughput",
		Help: "The total throughput of Hanzo Cloud",
	})
)
View Source 
var (
	WecomBotCache        = make(map[string]Provider)
	WecomBotMessageCache = make(map[string]string)
)
View Source 
var CloudHost = ""

Functions

func AddApplication 

func AddApplication(application *Application) (bool, error)

func AddArticle 

func AddArticle(article *Article) (bool, error)

func AddAsset 

func AddAsset(asset *Asset) (bool, error)

func AddCaase 

func AddCaase(caase *Caase) (bool, error)

func AddChat 

func AddChat(chat *Chat) (bool, error)

func AddConnection 

func AddConnection(connection *Connection) (bool, error)

func AddConsultation 

func AddConsultation(consultation *Consultation) (bool, error)

func AddContainer 

func AddContainer(container *Container) (bool, error)

func AddDetails 

func AddDetails(apps []*Application, lang string)

func AddDoctor 

func AddDoctor(doctor *Doctor) (bool, error)

func AddFile 

func AddFile(file *File) (bool, error)

func AddForm 

func AddForm(form *Form) (bool, error)

func AddGraph 

func AddGraph(graph *Graph) (bool, error)

func AddHospital 

func AddHospital(hospital *Hospital) (bool, error)

func AddImage 

func AddImage(image *Image) (bool, error)

func AddMachine 

func AddMachine(machine *Machine) (bool, error)

func AddMessage 

func AddMessage(message *Message) (bool, error)

func AddModelRoute 

func AddModelRoute(route *ModelRoute) (bool, error)

func AddNode 

func AddNode(node *Node) (bool, error)

func AddPatient 

func AddPatient(patient *Patient) (bool, error)

func AddPod 

func AddPod(pod *Pod) (bool, error)

func AddProvider 

func AddProvider(provider *Provider) (bool, error)

func AddRecord 

func AddRecord(record *Record, lang string) (bool, interface{}, error)

func AddRecords 

func AddRecords(records []*Record, syncEnabled bool, lang string) (bool, interface{}, error)

func AddScale 

func AddScale(scale *Scale) (bool, error)

func AddScan 

func AddScan(scan *Scan) (bool, error)

func AddSession 

func AddSession(session *Session) (bool, error)

func AddStore 

func AddStore(store *Store) (bool, error)

func AddTask 

func AddTask(task *Task) (bool, error)

func AddTemplate 

func AddTemplate(template *Template) (bool, error)

func AddTransactionForMessage 

func AddTransactionForMessage(message *Message) error

AddTransactionForMessage creates a withdraw transaction in Commerce for a message with price, sets the message's TransactionId, and if transaction creation fails, updates the message's ErrorText field in the database and returns an error.

func AddTreeFile 

func AddTreeFile(storeId string, userName string, key string, isLeaf bool, filename string, file multipart.File, lang string) (bool, []byte, error)

func AddVector 

func AddVector(vector *Vector) (bool, error)

func AddVectorsForFile 

func AddVectorsForFile(store *Store, fileName string, fileUrl string, lang string) (bool, error)

func AddVideo 

func AddVideo(video *Video) (bool, error)

func AddWorkflow 

func AddWorkflow(workflow *Workflow, lang string) (bool, error)

func ArchiveCrawlPreviewAsync 

func ArchiveCrawlPreviewAsync(owner, pageURL string, sr ScrapeResult, raw Crawl4AIResult)

ArchiveCrawlPreviewAsync archives a single-page preview crawl result asynchronously. It generates a job ID from the URL and timestamp, then stores both the converted ScrapeResult and the raw Crawl4AIResult.

func ArchiveCrawlResult 

func ArchiveCrawlResult(owner, jobID string, results []ScrapeResult, rawResults []Crawl4AIResult) error

ArchiveCrawlResult uploads crawl results as JSON to Hanzo Storage. The results are stored at {bucket}/{owner}/{jobID}/results.json.

func AtomicClaimScan 

func AtomicClaimScan(owner, name, hostname string) (int64, error)

AtomicClaimScan atomically updates a scan's state from "Pending" to "Running" This operation will only succeed for one instance due to the WHERE condition on state Returns the number of affected rows

func BuildCloudResponse 

func BuildCloudResponse(status uint32, body []byte, errMsg string) (*zap.Message, error)

── Cloud service response builder ────────────────────────────────────── BuildCloudResponse creates a native ZAP cloud service response. Used by controllers to build responses for incoming cloud requests.

func BuildGatewayResponse 

func BuildGatewayResponse(status uint32, body []byte, headers []byte) (*zap.Message, error)

── Gateway response builder ───────────────────────────────────────────── BuildGatewayResponse creates a response in the gateway's expected format. Layout: status(0:Uint32) + body(4:Bytes) + headers(12:Bytes)

func CanEditPatient 

func CanEditPatient(user *iam.User, patient *Patient) bool

func ClearThroughputPerSecond 

func ClearThroughputPerSecond()

func CloseConnection 

func CloseConnection(id string, code int, msg string) error

func CloseDbSession 

func CloseDbSession(id string, code int, msg string) error

func CommitRecord 

func CommitRecord(record *Record, lang string) (bool, map[string]interface{}, error)

func CommitRecordSecond 

func CommitRecordSecond(record *Record, lang string) (bool, error)

func CommitRecords 

func CommitRecords(records []*Record, lang string) (int, []map[string]interface{})

CommitRecords commits multiple records to the blockchain.

func CreateTables 

func CreateTables()

func DatastoreEnabled 

func DatastoreEnabled() bool

DatastoreEnabled returns true if the datastore peer is connected.

func DeleteAllLaterMessages 

func DeleteAllLaterMessages(messageId string) error

func DeleteApplication 

func DeleteApplication(application *Application, lang string) (bool, error)

func DeleteArticle 

func DeleteArticle(article *Article) (bool, error)

func DeleteAsset 

func DeleteAsset(asset *Asset) (bool, error)

func DeleteBeegoSession 

func DeleteBeegoSession(sessionIds []string)

func DeleteCaase 

func DeleteCaase(caase *Caase) (bool, error)

func DeleteChat 

func DeleteChat(chat *Chat) (bool, error)

func DeleteConnection 

func DeleteConnection(connection *Connection) (bool, error)

func DeleteConnectionById 

func DeleteConnectionById(id string) (bool, error)

func DeleteConsultation 

func DeleteConsultation(consultation *Consultation) (bool, error)

func DeleteContainer 

func DeleteContainer(container *Container) (bool, error)

func DeleteDoctor 

func DeleteDoctor(doctor *Doctor) (bool, error)

func DeleteFile 

func DeleteFile(file *File, lang string) (bool, error)

func DeleteForm 

func DeleteForm(form *Form) (bool, error)

func DeleteGraph 

func DeleteGraph(graph *Graph) (bool, error)

func DeleteHospital 

func DeleteHospital(hospital *Hospital) (bool, error)

func DeleteImage 

func DeleteImage(image *Image) (bool, error)

func DeleteMachine 

func DeleteMachine(machine *Machine) (bool, error)

func DeleteMessage 

func DeleteMessage(message *Message) (bool, error)

func DeleteMessagesByChat 

func DeleteMessagesByChat(message *Message) (bool, error)

func DeleteModelRoute 

func DeleteModelRoute(route *ModelRoute) (bool, error)

func DeleteNode 

func DeleteNode(node *Node) (bool, error)

func DeletePatient 

func DeletePatient(patient *Patient) (bool, error)

func DeletePod 

func DeletePod(pod *Pod) (bool, error)

func DeleteProvider 

func DeleteProvider(provider *Provider) (bool, error)

func DeleteRecord 

func DeleteRecord(record *Record) (bool, error)

func DeleteScale 

func DeleteScale(scale *Scale) (bool, error)

func DeleteScan 

func DeleteScan(scan *Scan) (bool, error)

func DeleteSession 

func DeleteSession(id string) (bool, error)

func DeleteSessionId 

func DeleteSessionId(id string, sessionId string) (bool, error)

func DeleteStore 

func DeleteStore(store *Store) (bool, error)

func DeleteTask 

func DeleteTask(task *Task) (bool, error)

func DeleteTemplate 

func DeleteTemplate(template *Template) (bool, error)

func DeleteTreeFile 

func DeleteTreeFile(storeId string, key string, isLeaf bool, lang string) (bool, error)

func DeleteVector 

func DeleteVector(vector *Vector) (bool, error)

func DeleteVectorsByFile 

func DeleteVectorsByFile(owner string, storeName string, fileKey string) (bool, error)

func DeleteVectorsByStore 

func DeleteVectorsByStore(owner string, storeName string) (bool, error)

func DeleteVideo 

func DeleteVideo(video *Video) (bool, error)

func DeleteWorkflow 

func DeleteWorkflow(workflow *Workflow) (bool, error)

func DeployApplication 

func DeployApplication(application *Application, lang string) (bool, error)

func DeployApplicationSync 

func DeployApplicationSync(application *Application, lang string) (bool, error)

func DocdbEnabled 

func DocdbEnabled() bool

DocdbEnabled returns true if the docdb peer is connected.

func GenerateWordCloudData 

func GenerateWordCloudData(messages []*Message, density int) (string, error)

func GetActivities 

func GetActivities(days int, user string, fieldNames []string, lang string) (map[string][]*Activity, error)

func GetAgentClients 

func GetAgentClients(agentProviderObj agent.AgentProvider) (*agent.AgentClients, error)

func GetAnswer 

func GetAnswer(provider string, question string, lang string) (string, *model.ModelResult, error)

func GetAnswerFake 

func GetAnswerFake(provider string, question string, lang string) (string, *model.ModelResult, error)

GetAnswerFake returns a hardcoded string without calling the LLM API, for fast local debugging. Switch between GetAnswer and GetAnswerFake by commenting one of the two call sites (e.g. in task_analyze.go). Replace fakeAnswer below with your real API response (multi-line raw string is fine).

func GetAnswerWithContext 

func GetAnswerWithContext(provider string, question string, history []*model.RawMessage, knowledge []*model.RawMessage, prompt string, lang string) (string, *model.ModelResult, error)

func GetApplicationCount 

func GetApplicationCount(owner, field, value string) (int64, error)

func GetApplicationFailureReason 

func GetApplicationFailureReason(namespace string, lang string) (string, error)

GetApplicationFailureReason returns the failure reason for an application deployment

func GetApplicationStatus 

func GetApplicationStatus(owner, name, namespace string, lang string) (string, error)

GetApplicationStatus returns application status as string

func GetArticleCount 

func GetArticleCount(owner, field, value string) (int64, error)

func GetAssetCount 

func GetAssetCount(owner, field, value string) (int64, error)

func GetCaaseCount 

func GetCaaseCount(owner, field, value string) (int64, error)

func GetChatCount 

func GetChatCount(owner string, field string, value string, store string) (int64, error)

func GetConnectionCount 

func GetConnectionCount(owner, status, field, value string) (int64, error)

func GetConsultationCount 

func GetConsultationCount(owner, field, value string) (int64, error)

func GetContainerCount 

func GetContainerCount(owner, field, value string) (int64, error)

func GetDbQuery 

func GetDbQuery(owner string, offset, limit int, field, value, sortField, sortOrder string) *dbx.SelectQuery

GetDbQuery builds a SelectQuery with pagination, filtering, and sorting. This replaces the old GetDbSession which returned an xorm.Session.

func GetDocChatAnswer 

func GetDocChatAnswer(owner, store string, req *DocChatRequest, lang string) (string, *model.ModelResult, error)

GetDocChatAnswer performs RAG: searches for relevant docs, then generates an answer.

func GetDoctorCount 

func GetDoctorCount(owner, field, value string) (int64, error)

func GetFileCount 

func GetFileCount(owner, field, value string) (int64, error)

func GetFormCount 

func GetFormCount(owner string, field, value string) (int64, error)

func GetGraphCount 

func GetGraphCount(owner string, field, value string) (int64, error)

func GetHospitalCount 

func GetHospitalCount(owner, field, value string) (int64, error)

func GetImageCount 

func GetImageCount(owner, field, value string) (int64, error)

func GetK8sStatus 

func GetK8sStatus(lang string) (string, error)

func GetKMSSecret 

func GetKMSSecret(name string) (string, error)

GetKMSSecret fetches a secret by name from KMS using the default system project. This is a convenience function for non-provider secrets.

func GetMachineCount 

func GetMachineCount(owner, field, value string) (int64, error)

func GetMessageCount 

func GetMessageCount(owner string, field string, value string, store string) (int64, error)

func GetModelProviderByProviderKey 

func GetModelProviderByProviderKey(providerKey string, lang string) (model.ModelProvider, error)

GetModelProviderByProviderKey retrieves both the provider and its model provider by API key

func GetModelRouteCount 

func GetModelRouteCount(owner, field, value string) (int64, error)

func GetNearMessageCount 

func GetNearMessageCount(user string, limitMinutes int) (int, error)

func GetNodeCount 

func GetNodeCount(owner, field, value string) (int64, error)

func GetOrgKMSSecret 

func GetOrgKMSSecret(name string, orgProjectID string) (string, error)

GetOrgKMSSecret fetches a secret scoped to an organization's KMS project.

func GetPatientCount 

func GetPatientCount(owner, field, value string) (int64, error)

func GetPodCount 

func GetPodCount(owner, field, value string) (int64, error)

func GetProviderCount 

func GetProviderCount(owner, storeName, field, value string) (int64, error)

func GetRecentRawMessages 

func GetRecentRawMessages(chat string, createdTime string, memoryLimit int) ([]*model.RawMessage, error)

func GetRecordCount 

func GetRecordCount(owner, field, value string) (int64, error)

func GetRefinedQuestion 

func GetRefinedQuestion(prompt string, knowledge string, question string) string

func GetScaleCount 

func GetScaleCount(owner string, field, value string) (int64, error)

func GetScanCount 

func GetScanCount(owner, field, value string) (int64, error)

func GetSearchIndexName 

func GetSearchIndexName(owner, store string) string

GetSearchIndexName returns the Hanzo Search index name for a given owner/store.

func GetSessionCount 

func GetSessionCount(owner, field, value string) (int64, error)

func GetStoreCount 

func GetStoreCount(name, field, value string) (int64, error)

func GetTaskCount 

func GetTaskCount(owner string, field, value string) (int64, error)

func GetTaskEffectiveScale 

func GetTaskEffectiveScale(task *Task) (string, error)

GetTaskEffectiveScale returns rubric text: from referenced Scale.Text when Task.Scale is set.

func GetTemplateCount 

func GetTemplateCount(owner, field, value string) (int64, error)

func GetTwoActiveBlockchainProvider 

func GetTwoActiveBlockchainProvider(owner string) (*Provider, *Provider, error)

func GetURL 

func GetURL(namespace string, lang string) (string, error)

GetURL retrieves the access URL for an application

func GetUsers 

func GetUsers(storeName, user string) ([]string, error)

func GetVectorCount 

func GetVectorCount(owner string, storeName string, field string, value string) (int64, error)

func GetVideoCount 

func GetVideoCount(owner string, field string, value string) (int64, error)

func GetWecomBotTokenAndKey 

func GetWecomBotTokenAndKey(botID string) (string, string, error)

func GetWorkflowCount 

func GetWorkflowCount(owner string, field, value string) (int64, error)

func GetZapNode 

func GetZapNode() *zap.Node

GetZapNode returns the ZAP node for handler registration. Used by controllers package to register service handlers.

func IndexDocuments 

func IndexDocuments(owner, store string, req *DocIndexRequest, lang string) (int, error)

IndexDocuments indexes documents into both Hanzo Search and Hanzo Vector.

func InitAdapter 

func InitAdapter()

func InitCleanupChats 

func InitCleanupChats()

func InitCommitRecordsTask 

func InitCommitRecordsTask()

func InitConfig 

func InitConfig()

func InitDb 

func InitDb()

func InitFlag 

func InitFlag()

func InitMessageTransactionRetry 

func InitMessageTransactionRetry()

func InitScanJobProcessor 

func InitScanJobProcessor()

InitScanJobProcessor initializes the scan job processor with a cron job

func InitStoreCount 

func InitStoreCount()

func InitZap 

func InitZap()

── Initialization ────────────────────────────────────────────────────── InitZap starts the ZAP node and connects to KV and SQL peers.

func IsAdmin 

func IsAdmin(user *iam.User) bool

func IsCrawl4AIAvailable 

func IsCrawl4AIAvailable() bool

IsCrawl4AIAvailable checks whether the Hanzo Crawl service is reachable.

func IsCrawlStorageConfigured 

func IsCrawlStorageConfigured() bool

IsCrawlStorageConfigured returns true if the crawl storage credentials are set.

func IsDoctor 

func IsDoctor(user *iam.User) bool

func IsPatient 

func IsPatient(user *iam.User) bool

func IsSessionDuplicated 

func IsSessionDuplicated(id string, sessionId string) (bool, error)

func JSONScan 

func JSONScan(dst interface{}, src interface{}) error

JSONScan is a helper for fields that are scanned-from-JSON-text via a pointer-receiver Scan method. Use it inside per-type Scanner impls so they all share the same string/bytes/nil handling.

func JSONValue 

func JSONValue(v interface{}) (driver.Value, error)

JSONValue marshals v as a JSON string for driver.Valuer impls.

func MakeMsgResponse 

func MakeMsgResponse(content string, streamId string) (string, error)

func PopulateStoreCounts 

func PopulateStoreCounts(stores []*Store) error

func PrepareTextToSpeech 

func PrepareTextToSpeech(storeId, providerId, messageId, text string, lang string) (*Message, *Chat, tts.TextToSpeechProvider, context.Context, error)

PrepareTextToSpeech prepares the text-to-speech conversion

func QueryRecord 

func QueryRecord(id string, lang string) (string, error)

func QueryRecordSecond 

func QueryRecordSecond(id string, lang string) (string, error)

func RefineMessageFiles 

func RefineMessageFiles(message *Message, origin string, lang string) error

func RefreshFileVectors 

func RefreshFileVectors(file *File, lang string) (bool, error)

func RefreshMcpTools 

func RefreshMcpTools(provider *Provider) error

func RefreshStoreVectors 

func RefreshStoreVectors(store *Store, lang string) (bool, error)

func ResolveProviderSecret 

func ResolveProviderSecret(provider *Provider) error

── Public API ────────────────────────────────────────────────────────────── ResolveProviderSecret resolves KMS-backed secret fields for a provider. If KMS is configured and provider fields start with "kms://", each secret is fetched from KMS. Otherwise, DB values are used as-is.

Supported provider fields:

  • ClientSecret
  • UserKey
  • SignKey

Convention: store "kms://SECRET_NAME" in these fields in the database. At runtime, they are resolved to actual secret values.

Multi-tenant scoping:

  • Admin-owned providers use the default KMS_PROJECT_ID
  • Org-owned providers can set "kms-project:{projectId}" in ConfigText to scope secrets to the org's own KMS project

func ScanAssetsFromProvider 

func ScanAssetsFromProvider(owner string, providerName string) (bool, error)

func ScanNeedCommitRecords 

func ScanNeedCommitRecords()

ScanNeedCommitRecords scans the database table for records that need to be committed but have not yet been committed.

func SetDefaultVodClient 

func SetDefaultVodClient(lang string) error

func SplitLastN 

func SplitLastN(s, sep string, n int) []string

func StopZap 

func StopZap()

StopZap gracefully shuts down the ZAP node.

func SyncDefaultProvidersToStore 

func SyncDefaultProvidersToStore(store *Store) error

func SyncDockerContainers 

func SyncDockerContainers(owner string) (bool, error)

func SyncImagesCloud 

func SyncImagesCloud(owner string, lang string) (bool, error)

func SyncKubernetesPods 

func SyncKubernetesPods(owner string) (bool, error)

func SyncMachinesCloud 

func SyncMachinesCloud(owner string, lang string) (bool, error)

func UndeployApplication 

func UndeployApplication(owner, name, namespace string, lang string) (bool, error)

func UndeployApplicationSync 

func UndeployApplicationSync(owner, name, namespace string, lang string) (bool, error)

UndeployApplicationSync undeploys application and waits for it to be completely removed

func UpdateApplication 

func UpdateApplication(id string, application *Application, lang string) (bool, error)

func UpdateApplicationStatus 

func UpdateApplicationStatus(owner string, name string, status string, lang string) error

func UpdateArticle 

func UpdateArticle(id string, article *Article) (bool, error)

func UpdateAsset 

func UpdateAsset(id string, asset *Asset) (bool, error)

func UpdateCaase 

func UpdateCaase(id string, caase *Caase) (bool, error)

func UpdateChat 

func UpdateChat(id string, chat *Chat) (bool, error)

func UpdateChatStats 

func UpdateChatStats(chat *Chat, ttsResult *tts.TextToSpeechResult) error

func UpdateConnection 

func UpdateConnection(id string, connection *Connection, columns ...string) (bool, error)

func UpdateConsultation 

func UpdateConsultation(id string, consultation *Consultation) (bool, error)

func UpdateContainer 

func UpdateContainer(id string, container *Container, lang string) (bool, error)

func UpdateDoctor 

func UpdateDoctor(id string, doctor *Doctor) (bool, error)

func UpdateFile 

func UpdateFile(id string, file *File) (bool, error)

func UpdateFilesStatusByStore 

func UpdateFilesStatusByStore(owner string, storeName string, status FileStatus) error

func UpdateForm 

func UpdateForm(id string, form *Form, lang string) (bool, error)

func UpdateGraph 

func UpdateGraph(id string, graph *Graph) (bool, error)

func UpdateHospital 

func UpdateHospital(id string, hospital *Hospital) (bool, error)

func UpdateImage 

func UpdateImage(id string, image *Image) (bool, error)

func UpdateMachine 

func UpdateMachine(id string, machine *Machine) (bool, error)

func UpdateMessage 

func UpdateMessage(id string, message *Message, isHitOnly bool) (bool, error)

func UpdateModelRoute 

func UpdateModelRoute(owner string, modelName string, route *ModelRoute) (bool, error)

func UpdateNode 

func UpdateNode(id string, node *Node) (bool, error)

func UpdatePatient 

func UpdatePatient(id string, patient *Patient) (bool, error)

func UpdatePod 

func UpdatePod(id string, pod *Pod, lang string) (bool, error)

func UpdateProvider 

func UpdateProvider(id string, provider *Provider) (bool, error)

func UpdateRecord 

func UpdateRecord(id string, record *Record, lang string) (bool, error)

func UpdateRecordFields 

func UpdateRecordFields(id string, fields map[string]interface{}, lang string) (bool, error)

func UpdateRecordInternal 

func UpdateRecordInternal(id int, record Record) error

func UpdateScale 

func UpdateScale(id string, scale *Scale) (bool, error)

func UpdateScan 

func UpdateScan(id string, scan *Scan) (bool, error)

func UpdateSession 

func UpdateSession(id string, session *Session) (bool, error)

func UpdateStore 

func UpdateStore(id string, store *Store) (bool, error)

func UpdateTask 

func UpdateTask(id string, task *Task) (bool, error)

func UpdateTemplate 

func UpdateTemplate(id string, template *Template) (bool, error)

func UpdateTreeFile 

func UpdateTreeFile(storeId string, key string, file *TreeFile) bool

func UpdateVector 

func UpdateVector(id string, vector *Vector, lang string) (bool, error)

func UpdateVideo 

func UpdateVideo(id string, video *Video) (bool, error)

func UpdateWorkflow 

func UpdateWorkflow(id string, workflow *Workflow, lang string) (bool, error)

func UploadFileToStorageSafe 

func UploadFileToStorageSafe(user string, tag string, parent string, fullFilePath string, fileBytes []byte) (string, error)

func ValidateTransactionForMessage 

func ValidateTransactionForMessage(message *Message) error

ValidateTransactionForMessage validates that the user has sufficient balance before committing an expensive AI generation. Checks balance via Commerce.

func WriteCloseMessage 

func WriteCloseMessage(guacSession *guacamole.Session, mode string, code int, msg string)

func ZapDatastoreExec 

func ZapDatastoreExec(ctx context.Context, sqlStmt string, args ...interface{}) error

── Datastore client (native ZAP-to-ZAP → ClickHouse) ─────────────────── ZapDatastoreExec executes an INSERT/DDL on ClickHouse via native ZAP binary.

func ZapDocdbExec 

func ZapDocdbExec(ctx context.Context, sql string, args ...interface{}) error

ZapDocdbExec executes a write query on DocDB via native ZAP binary.

func ZapDocdbQuery 

func ZapDocdbQuery(ctx context.Context, sql string, args ...interface{}) ([]map[string]interface{}, error)

── DocDB client (native ZAP-to-ZAP → FerretDB) ───────────────────────── ZapDocdbQuery executes a read query on DocDB via native ZAP binary.

func ZapEnabled 

func ZapEnabled() bool

ZapEnabled returns true if the ZAP node is running.

func ZapKVDel 

func ZapKVDel(ctx context.Context, key string) error

ZapKVDel deletes a key via native ZAP binary.

func ZapKVGet 

func ZapKVGet(ctx context.Context, key string) (string, error)

── KV client (native ZAP-to-ZAP) ────────────────────────────────────── ZapKVGet fetches a key from KV via native ZAP binary.

func ZapKVSet 

func ZapKVSet(ctx context.Context, key, value string) error

ZapKVSet stores a key/value pair via native ZAP binary.

func ZapKVSetEx 

func ZapKVSetEx(ctx context.Context, key, value string, ttlSeconds int) error

ZapKVSetEx stores a key/value with TTL via native ZAP binary.

func ZapSQLExec 

func ZapSQLExec(ctx context.Context, sql string, args ...interface{}) error

ZapSQLExec executes a write query via native ZAP binary.

func ZapSQLQuery 

func ZapSQLQuery(ctx context.Context, sql string, args ...interface{}) ([]map[string]interface{}, error)

── SQL client (native ZAP-to-ZAP) ───────────────────────────────────── ZapSQLQuery executes a read query via native ZAP binary.

Types

type Activity 

type Activity struct {
	Date       string `json:"date"`
	FieldCount map[string]int
}

type Adapter 

type Adapter struct {
	DbName string
	// contains filtered or unexported fields
}

Adapter represents the database adapter for storage.

func NewAdapter 

func NewAdapter(driverName string, dataSourceName string) *Adapter

NewAdapter is the constructor for Adapter.

func NewAdapterWithDbName 

func NewAdapterWithDbName(driverName string, dataSourceName string, dbName string) *Adapter

func (*Adapter) CreateDatabase 

func (a *Adapter) CreateDatabase() error

func (*Adapter) RawDB 

func (a *Adapter) RawDB() *sql.DB

RawDB returns the underlying *sql.DB for direct access when needed.

type AlibabaCloudParser 

type AlibabaCloudParser struct{}

AlibabaCloudParser implements CloudParser for Alibaba Cloud

func (*AlibabaCloudParser) ScanAssets 

func (p *AlibabaCloudParser) ScanAssets(owner string, provider *Provider) ([]*Asset, error)

ScanAssets scans all resources from Alibaba Cloud

type Application 

type Application struct {
	Owner              string                    `db:"pk" json:"owner"`
	Name               string                    `db:"pk" json:"name"`
	CreatedTime        string                    `json:"createdTime"`
	UpdatedTime        string                    `json:"updatedTime"`
	DisplayName        string                    `json:"displayName"`
	Description        string                    `json:"description"`
	Template           string                    `json:"template"` // Reference to Template.Name
	Parameters         string                    `json:"parameters"`
	Manifest           string                    `json:"manifest"`  // Deployment manifest
	Status             string                    `json:"status"`    // Running, Pending, Failed, Not Deployed
	Namespace          string                    `json:"namespace"` // Kubernetes namespace (auto-generated)
	URL                string                    `json:"url"`       // Available service URL
	Details            *ApplicationView          `db:"-" json:"details,omitempty"`
	BasicConfigOptions []applicationConfigOption `json:"basicConfigOptions"`
}

func GetApplication 

func GetApplication(id string) (*Application, error)

func GetApplications 

func GetApplications(owner string) ([]*Application, error)

func GetPaginationApplications 

func GetPaginationApplications(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Application, error)

type ApplicationEvent 

type ApplicationEvent struct {
	Name           string `json:"name"`           // Event name
	Type           string `json:"type"`           // Event type: Normal, Warning
	Reason         string `json:"reason"`         // Event reason
	Message        string `json:"message"`        // Event message
	InvolvedObject string `json:"involvedObject"` // Related object
	Source         string `json:"source"`         // Event source
	Count          int    `json:"count"`          // Event occurrence count
	FirstTime      string `json:"firstTime"`      // First occurrence time
	LastTime       string `json:"lastTime"`       // Last occurrence time
}

type ApplicationView 

type ApplicationView struct {
	Services    []ServiceDetail    `json:"services"`
	Credentials []EnvVariable      `json:"credentials"`
	Deployments []DeploymentDetail `json:"deployments"`
	Events      []ApplicationEvent `json:"events"`
	Status      string             `json:"status"`
	CreatedTime string             `json:"createdTime"`
	Namespace   string             `json:"namespace"`
	Metrics     *ResourceMetrics   `json:"metrics,omitempty"`
}

func GetApplicationView 

func GetApplicationView(namespace string, lang string) (*ApplicationView, error)

GetApplicationView retrieves application view from cache with fallback

type Article 

type Article struct {
	Owner       string   `db:"pk" json:"owner"`
	Name        string   `db:"pk" json:"name"`
	CreatedTime string   `json:"createdTime"`
	DisplayName string   `json:"displayName"`
	Workflow    string   `json:"workflow"`
	Type        string   `json:"type"`
	Text        string   `json:"text"`
	Content     []*Block `json:"content"`
	Glossary    []string `json:"glossary"`
}

func GetArticle 

func GetArticle(id string) (*Article, error)

func GetArticles 

func GetArticles(owner string) ([]*Article, error)

func GetGlobalArticles 

func GetGlobalArticles() ([]*Article, error)

func GetMaskedArticle 

func GetMaskedArticle(article *Article, isMaskEnabled bool) *Article

func GetMaskedArticles 

func GetMaskedArticles(articles []*Article, isMaskEnabled bool) []*Article

func GetPaginationArticles 

func GetPaginationArticles(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Article, error)

func (*Article) GetId 

func (article *Article) GetId() string

type Asset 

type Asset struct {
	Owner       string `db:"pk" json:"owner"`
	Name        string `db:"pk" json:"name"`
	CreatedTime string `json:"createdTime"`
	UpdatedTime string `json:"updatedTime"`
	DisplayName string `json:"displayName"`
	Provider    string `json:"provider"`
	Id          string `json:"id"`
	Type        string `json:"type"`
	Region      string `json:"region"`
	Zone        string `json:"zone"`
	State       string `json:"state"`
	Tag         string `json:"tag"`
	Username    string `json:"username"`
	Password    string `json:"password"`
	Properties  string `json:"properties"`
}

func GetAsset 

func GetAsset(id string) (*Asset, error)

func GetAssets 

func GetAssets(owner string) ([]*Asset, error)

func GetMaskedAsset 

func GetMaskedAsset(asset *Asset, isMaskEnabled bool) *Asset

func GetMaskedAssets 

func GetMaskedAssets(assets []*Asset, isMaskEnabled bool) []*Asset

func GetPaginationAssets 

func GetPaginationAssets(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Asset, error)

func (*Asset) GetId 

func (asset *Asset) GetId() string

func (*Asset) GetScanTarget 

func (asset *Asset) GetScanTarget() (string, error)

type Block 

type Block struct {
	Type   string `json:"type"`
	Text   string `json:"text"`
	TextEn string `json:"textEn"`
	Prompt string `json:"prompt"`
	State  string `json:"state"`
}

type Caase 

type Caase struct {
	Owner                        string `db:"pk" json:"owner"`
	Name                         string `db:"pk" json:"name"`
	CreatedTime                  string `json:"createdTime"`
	UpdatedTime                  string `json:"updatedTime"`
	DisplayName                  string `json:"displayName"`
	Symptoms                     string `json:"symptoms"`
	Diagnosis                    string `json:"diagnosis"`
	DiagnosisDate                string `json:"diagnosisDate"`
	Prescription                 string `json:"prescription"`
	FollowUp                     string `json:"followUp"`
	Variation                    bool   `json:"variation"`
	HISInterfaceInfo             string `json:"hisInterfaceInfo"`
	PrimaryCarePhysician         string `json:"primaryCarePhysician"`
	Type                         string `json:"type"`
	PatientName                  string `json:"patientName"`
	DoctorName                   string `json:"doctorName"`
	HospitalName                 string `json:"hospitalName"`
	SpecialistAllianceId         string `json:"specialistAllianceId"`
	IntegratedCareOrganizationId string `json:"integratedCareOrganizationId"`
}

func FilterCaasesByUser 

func FilterCaasesByUser(user *iam.User, caases []*Caase) []*Caase

func GetCaase 

func GetCaase(id string) (*Caase, error)

func GetCaases 

func GetCaases(owner string) ([]*Caase, error)

func GetMaskedCaase 

func GetMaskedCaase(caase *Caase, errs ...error) (*Caase, error)

func GetMaskedCaases 

func GetMaskedCaases(caases []*Caase, errs ...error) ([]*Caase, error)

func GetPaginationCaases 

func GetPaginationCaases(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Caase, error)

type CacheManager 

type CacheManager struct {
	// contains filtered or unexported fields
}

func (*CacheManager) Start 

func (cm *CacheManager) Start(lang string) error

Start begins the cache manager

func (*CacheManager) Stop 

func (cm *CacheManager) Stop()

Stop stops the cache manager

type CachedMetrics 

type CachedMetrics struct {
	TotalCPU         resource.Quantity `json:"totalCPU"`
	TotalMemory      resource.Quantity `json:"totalMemory"`
	PodCount         int               `json:"podCount"`
	CPUPercentage    float64           `json:"cpuPercentage"`
	MemoryPercentage float64           `json:"memoryPercentage"`
	LastUpdated      time.Time         `json:"lastUpdated"`
}

type Chat 

type Chat struct {
	Owner         string   `db:"pk" json:"owner"`
	Name          string   `db:"pk" json:"name"`
	CreatedTime   string   `json:"createdTime"`
	UpdatedTime   string   `json:"updatedTime"`
	Organization  string   `json:"organization"`
	DisplayName   string   `json:"displayName"`
	Store         string   `json:"store"`
	ModelProvider string   `json:"modelProvider"`
	Category      string   `json:"category"`
	Type          string   `json:"type"`
	User          string   `json:"user"`
	User1         string   `json:"user1"`
	User2         string   `json:"user2"`
	Users         []string `json:"users"`
	ClientIp      string   `json:"clientIp"`
	UserAgent     string   `json:"userAgent"`
	ClientIpDesc  string   `json:"clientIpDesc"`
	UserAgentDesc string   `json:"userAgentDesc"`
	MessageCount  int      `json:"messageCount"`
	TokenCount    int      `json:"tokenCount"`
	Price         float64  `json:"price"`
	Currency      string   `json:"currency"`
	IsHidden      bool     `json:"isHidden"`
	IsDeleted     bool     `json:"isDeleted"`
	NeedTitle     bool     `json:"needTitle"`
}

func FilterChatsByTimeRange 

func FilterChatsByTimeRange(chats []*Chat, startTime, endTime string) []*Chat

func GetChat 

func GetChat(id string) (*Chat, error)

func GetChats 

func GetChats(owner string, storeName string, user string) ([]*Chat, error)

func GetGlobalChats 

func GetGlobalChats() ([]*Chat, error)

func GetPaginationChats 

func GetPaginationChats(owner string, offset, limit int, field, value, sortField, sortOrder string, store string) ([]*Chat, error)

func (*Chat) GetId 

func (chat *Chat) GetId() string

type CloudParser 

type CloudParser interface {
	// ScanAssets scans all resources from the cloud provider and returns them as Asset objects
	ScanAssets(owner string, provider *Provider) ([]*Asset, error)
}

CloudParser defines the interface for cloud resource scanning

func NewCloudParser 

func NewCloudParser(providerType string) (CloudParser, error)

NewCloudParser creates a new CloudParser instance based on the provider type

type Connection 

type Connection struct {
	Owner         string   `db:"pk" json:"owner"`
	Name          string   `db:"pk" json:"name"`
	CreatedTime   string   `json:"createdTime"`
	StartTime     string   `json:"startTime"`
	EndTime       string   `json:"endTime"`
	Protocol      string   `json:"protocol"`
	ConnectionId  string   `json:"connectionId"`
	Node          string   `json:"node"`
	Creator       string   `json:"creator"`
	ClientIp      string   `json:"clientIp"`
	UserAgent     string   `json:"userAgent"`
	ClientIpDesc  string   `json:"clientIpDesc"`
	UserAgentDesc string   `json:"userAgentDesc"`
	Width         int      `json:"width"`
	Height        int      `json:"height"`
	Status        string   `json:"status"`
	Recording     string   `json:"recording"`
	Code          int      `json:"code"`
	Message       string   `json:"message"`
	Mode          string   `json:"mode"`
	Operations    []string `db:"json varchar(1000)" json:"operations"`
	Reviewed      bool     `json:"reviewed"`
	CommandCount  int64    `json:"commandCount"`
}

func CreateConnection 

func CreateConnection(connection *Connection, nodeId string, mode string) (*Connection, error)

func GetConnection 

func GetConnection(id string) (*Connection, error)

func GetConnections 

func GetConnections(owner string) ([]*Connection, error)

func GetPaginationConnections 

func GetPaginationConnections(owner, status string, offset, limit int, field, value, sortField, sortOrder string) ([]*Connection, error)

func GetSessionsByStatus 

func GetSessionsByStatus(statuses []string) ([]*Connection, error)

func (*Connection) GetId 

func (s *Connection) GetId() string

type Consultation 

type Consultation struct {
	Owner       string   `db:"pk" json:"owner"`
	Name        string   `db:"pk" json:"name"`
	CreatedTime string   `json:"createdTime"`
	UpdatedTime string   `json:"updatedTime"`
	DisplayName string   `json:"displayName"`
	PatientName string   `json:"patientName"`
	DoctorNames []string `json:"doctorNames"`
	ExpiredTime string   `json:"expiredTime"`
	State       string   `json:"state"`
}

func FilterConsultationsByUser 

func FilterConsultationsByUser(user *iam.User, consultations []*Consultation) []*Consultation

func GetConsultation 

func GetConsultation(id string) (*Consultation, error)

func GetConsultations 

func GetConsultations(owner string) ([]*Consultation, error)

func GetMaskedConsultation 

func GetMaskedConsultation(consultation *Consultation, errs ...error) (*Consultation, error)

func GetMaskedConsultations 

func GetMaskedConsultations(consultations []*Consultation, errs ...error) ([]*Consultation, error)

func GetPaginationConsultations 

func GetPaginationConsultations(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Consultation, error)

type Container 

type Container struct {
	Owner       string `db:"pk" json:"owner"`
	Name        string `db:"pk" json:"name"`
	DisplayName string `json:"displayName"`
	Provider    string `json:"provider"`
	CreatedTime string `json:"createdTime"`
	Image       string `json:"image"`
	ImageId     string `json:"imageId"`
	Command     string `json:"command"`
	SizeRw      int64  `json:"sizeRw,omitempty"`
	SizeRootFs  int64  `json:"sizeRootFs,omitempty"`
	// Labels      map[string]string
	State  string `json:"state"`
	Status string `json:"status"`
	Ports  string `json:"ports"`
}

func GetContainer 

func GetContainer(id string) (*Container, error)

func GetContainers 

func GetContainers(owner string) ([]*Container, error)

func GetMaskedContainer 

func GetMaskedContainer(container *Container, errs ...error) (*Container, error)

func GetMaskedContainers 

func GetMaskedContainers(containers []*Container, errs ...error) ([]*Container, error)

func GetPaginationContainers 

func GetPaginationContainers(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Container, error)

func (*Container) GetId 

func (container *Container) GetId() string

type ContainerDetail 

type ContainerDetail struct {
	Name      string           `json:"name"`
	Image     string           `json:"image"`
	Resources ResourceRequests `json:"resources"`
}

type ContentBlock 

type ContentBlock struct {
	Type    string `json:"type"` // "paragraph", "code", "list"
	Text    string `json:"text"`
	Section string `json:"section,omitempty"`
}

ContentBlock represents a block of extracted content (paragraph, code, list).

type Crawl4AIBrowserConfig 

type Crawl4AIBrowserConfig struct {
	Headless bool `json:"headless"`
}

Crawl4AIBrowserConfig controls the headless browser settings.

type Crawl4AICrawlerParams 

type Crawl4AICrawlerParams struct {
	WordCountThreshold   int  `json:"word_count_threshold"`
	ExcludeExternalLinks bool `json:"exclude_external_links"`
	ProcessIframes       bool `json:"process_iframes"`
}

Crawl4AICrawlerParams controls the crawl extraction behavior.

type Crawl4AIRequest 

type Crawl4AIRequest struct {
	Urls          []string               `json:"urls"`
	BrowserConfig *Crawl4AIBrowserConfig `json:"browser_config,omitempty"`
	CrawlerParams *Crawl4AICrawlerParams `json:"crawler_params,omitempty"`
}

Crawl4AIRequest is the request body for the Hanzo Crawl /crawl endpoint.

type Crawl4AIResponse 

type Crawl4AIResponse struct {
	TaskID  string           `json:"task_id"`
	Status  string           `json:"status"`
	Results []Crawl4AIResult `json:"results,omitempty"`
}

Crawl4AIResponse is the response from the Hanzo Crawl /crawl endpoint.

type Crawl4AIResult 

type Crawl4AIResult struct {
	URL      string                         `json:"url"`
	Markdown string                         `json:"markdown"`
	Success  bool                           `json:"success"`
	Links    map[string][]map[string]string `json:"links,omitempty"`
	Media    map[string][]map[string]string `json:"media,omitempty"`
	Metadata map[string]interface{}         `json:"metadata,omitempty"`
}

Crawl4AIResult holds the crawl output for a single URL.

func CrawlWithCrawl4AI 

func CrawlWithCrawl4AI(urls []string) ([]Crawl4AIResult, error)

CrawlWithCrawl4AI sends URLs to the Hanzo Crawl service for JS-rendered crawling. It submits a crawl job, polls for completion, and returns the results.

type CrawlArchive 

type CrawlArchive struct {
	Owner      string           `json:"owner"`
	JobID      string           `json:"job_id"`
	Timestamp  string           `json:"timestamp"`
	Results    []ScrapeResult   `json:"results"`
	RawResults []Crawl4AIResult `json:"raw_results,omitempty"`
}

CrawlArchive is the envelope stored in Hanzo Storage for a crawl job's results. It stores both the converted ScrapeResult data and the raw Crawl4AIResult data when available, to preserve the full fidelity of crawl output.

func GetArchivedCrawlResult 

func GetArchivedCrawlResult(owner, jobID string) (*CrawlArchive, error)

GetArchivedCrawlResult retrieves previously archived crawl results from Hanzo Storage.

type DefaultSearchProvider 

type DefaultSearchProvider struct {
	// contains filtered or unexported fields
}

func NewDefaultSearchProvider 

func NewDefaultSearchProvider(owner string) (*DefaultSearchProvider, error)

func (*DefaultSearchProvider) Search 

func (p *DefaultSearchProvider) Search(relatedStores []string, embeddingProviderName string, embeddingProviderObj embedding.EmbeddingProvider, modelProviderName string, text string, knowledgeCount int, lang string) ([]Vector, *embedding.EmbeddingResult, error)

type DeploymentDetail 

type DeploymentDetail struct {
	Name          string            `json:"name"`
	Replicas      int32             `json:"replicas"`
	ReadyReplicas int32             `json:"readyReplicas"`
	Containers    []ContainerDetail `json:"containers"`
	CreatedTime   string            `json:"createdTime"`
	Status        string            `json:"status"`
}

type DiskDetail 

type DiskDetail struct {
	DiskId             string
	Size               int32
	Category           string
	Type               string
	Encrypted          bool
	InstanceId         string
	DiskChargeType     string
	DeleteWithInstance bool
	Status             string
}

DiskDetail holds detailed information for a disk

type DocChatRequest 

type DocChatRequest struct {
	Query  string `json:"query"`
	Tag    string `json:"tag,omitempty"`
	Stream bool   `json:"stream,omitempty"`
	Prompt string `json:"prompt,omitempty"` // Custom system prompt (set by client)
}

DocChatRequest is the request body for RAG chat over documentation.

type DocIndex 

type DocIndex struct {
	ID          string   `json:"id"`
	PageID      string   `json:"page_id"`
	Title       string   `json:"title"`
	URL         string   `json:"url"`
	Content     string   `json:"content"`
	Section     string   `json:"section,omitempty"`
	SectionID   string   `json:"section_id,omitempty"`
	Tag         string   `json:"tag,omitempty"`
	Breadcrumbs []string `json:"breadcrumbs,omitempty"`
}

DocIndex represents a single indexed documentation chunk.

type DocIndexRequest 

type DocIndexRequest struct {
	Documents []DocIndex `json:"documents"`
	Replace   bool       `json:"replace,omitempty"`
}

DocIndexRequest is the request body for indexing documents.

type DocSearchRequest 

type DocSearchRequest struct {
	Query string `json:"query"`
	Tag   string `json:"tag,omitempty"`
	Limit int    `json:"limit,omitempty"`
	Mode  string `json:"mode,omitempty"` // "hybrid", "fulltext", "vector"
}

DocSearchRequest is the request body for searching documents.

type DocSearchResult 

type DocSearchResult struct {
	ID          string   `json:"id"`
	URL         string   `json:"url"`
	Type        string   `json:"type"` // "page", "heading", "text"
	Content     string   `json:"content"`
	Breadcrumbs []string `json:"breadcrumbs,omitempty"`
}

DocSearchResult is a single result returned by SearchDocuments.

func SearchDocuments 

func SearchDocuments(owner, store string, req *DocSearchRequest, lang string) ([]DocSearchResult, error)

SearchDocuments performs hybrid search across Hanzo Search and Hanzo Vector.

type DocStatsResponse 

type DocStatsResponse struct {
	DocumentCount int              `json:"documentCount"`
	IsIndexing    bool             `json:"isIndexing"`
	Fields        map[string]int64 `json:"fields,omitempty"`
}

DocStatsResponse contains index statistics.

func GetDocIndexStats 

func GetDocIndexStats(owner, store string) (*DocStatsResponse, error)

GetDocIndexStats returns statistics about the Meilisearch index.

type Doctor 

type Doctor struct {
	Owner        string `db:"pk" json:"owner"`
	Name         string `db:"pk" json:"name"`
	CreatedTime  string `json:"createdTime"`
	UpdatedTime  string `json:"updatedTime"`
	DisplayName  string `json:"displayName"`
	Department   string `json:"department"`
	Gender       string `json:"gender"`
	AccessLevel  string `json:"accessLevel"`
	HospitalName string `json:"hospitalName"`
}

func GetDoctor 

func GetDoctor(id string) (*Doctor, error)

func GetDoctors 

func GetDoctors(owner string) ([]*Doctor, error)

func GetMaskedDoctor 

func GetMaskedDoctor(doctor *Doctor, errs ...error) (*Doctor, error)

func GetMaskedDoctors 

func GetMaskedDoctors(doctors []*Doctor, errs ...error) ([]*Doctor, error)

func GetPaginationDoctors 

func GetPaginationDoctors(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Doctor, error)

type EcsInstanceDetail 

type EcsInstanceDetail struct {
	InstanceId         string
	InstanceType       string
	ImageId            string
	OSName             string
	Cpu                int32
	Memory             int32
	PublicIp           string
	PrivateIp          string
	InstanceChargeType string
	Status             string
}

EcsInstanceDetail holds detailed information for an ECS instance

type EnvVariable 

type EnvVariable struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type EventCache 

type EventCache struct {
	Namespace string               `json:"namespace"` // Namespace name
	Events    map[string]*v1.Event `json:"events"`    // Event name -> Event object
}

EventCache represents namespace-level event cache

type ExampleQuestion 

type ExampleQuestion struct {
	Title string `json:"title"`
	Text  string `json:"text"`
	Image string `json:"image"`
}

type ExampleQuestionList 

type ExampleQuestionList []ExampleQuestion

ExampleQuestionList implements sql.Scanner for slice-of-ExampleQuestion, stored as JSON in a TEXT column.

func (*ExampleQuestionList) Scan 

func (l *ExampleQuestionList) Scan(src interface{}) error

func (ExampleQuestionList) Value 

func (l ExampleQuestionList) Value() (driver.Value, error)

type File 

type File struct {
	Owner           string     `db:"pk" json:"owner"`
	Name            string     `db:"pk" json:"name"`
	CreatedTime     string     `json:"createdTime"`
	Filename        string     `json:"filename"`
	Size            int64      `json:"size"`
	Store           string     `json:"store"`
	StorageProvider string     `json:"storageProvider"`
	Url             string     `json:"url"`
	TokenCount      int        `json:"tokenCount"`
	Status          FileStatus `json:"status"`
	ErrorText       string     `json:"errorText"`
}

func GetFile 

func GetFile(id string) (*File, error)

func GetFiles 

func GetFiles(owner string) ([]*File, error)

func GetFilesByStore 

func GetFilesByStore(owner string, store string) ([]*File, error)

func GetGlobalFiles 

func GetGlobalFiles() ([]*File, error)

func GetPaginationFiles 

func GetPaginationFiles(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*File, error)

func (*File) GetId 

func (file *File) GetId() string

type FileStatus 

type FileStatus string
const (
	FileStatusPending    FileStatus = "Pending"
	FileStatusProcessing FileStatus = "Processing"
	FileStatusFinished   FileStatus = "Finished"
	FileStatusError      FileStatus = "Error"
)

type Form 

type Form struct {
	Owner       string      `db:"pk" json:"owner"`
	Name        string      `db:"pk" json:"name"`
	CreatedTime string      `json:"createdTime"`
	DisplayName string      `json:"displayName"`
	Position    string      `json:"position"`
	Category    string      `json:"category"`
	Type        string      `json:"type"`
	Tag         string      `json:"tag"`
	Url         string      `json:"url"`
	FormItems   []*FormItem `json:"formItems"`
}

func GetForm 

func GetForm(id string) (*Form, error)

func GetForms 

func GetForms(owner string) ([]*Form, error)

func GetGlobalForms 

func GetGlobalForms() ([]*Form, error)

func GetMaskedForm 

func GetMaskedForm(form *Form, isMaskEnabled bool) *Form

func GetMaskedForms 

func GetMaskedForms(forms []*Form, isMaskEnabled bool) []*Form

func GetPaginationForms 

func GetPaginationForms(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Form, error)

func (*Form) GetId 

func (form *Form) GetId() string

type FormItem 

type FormItem struct {
	Name    string `json:"name"`
	Label   string `json:"label"`
	Type    string `json:"type"`
	Visible bool   `json:"visible"`
	Width   string `json:"width"`
}

type FromUser 

type FromUser struct {
	UserId string `json:"userid"`
}

type GaugeVecInfo 

type GaugeVecInfo struct {
	Method     string  `json:"method"`
	Name       string  `json:"name"`
	Throughput float64 `json:"throughput"`
}

type Graph 

type Graph struct {
	Owner       string `db:"pk" json:"owner"`
	Name        string `db:"pk" json:"name"`
	CreatedTime string `json:"createdTime"`
	DisplayName string `json:"displayName"`
	Category    string `json:"category"`
	Layout      string `json:"layout"`
	Density     int    `json:"density"`
	Store       string `json:"store"`
	StartTime   string `json:"startTime"`
	EndTime     string `json:"endTime"`
	Text        string `json:"text"`
	ErrorText   string `json:"errorText"`
}

func GetGlobalGraphs 

func GetGlobalGraphs() ([]*Graph, error)

func GetGraph 

func GetGraph(id string) (*Graph, error)

func GetGraphs 

func GetGraphs(owner string) ([]*Graph, error)

func GetMaskedGraph 

func GetMaskedGraph(graph *Graph, isMaskEnabled bool) *Graph

func GetMaskedGraphs 

func GetMaskedGraphs(graphs []*Graph, isMaskEnabled bool) []*Graph

func GetPaginationGraphs 

func GetPaginationGraphs(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Graph, error)

func (*Graph) GetId 

func (graph *Graph) GetId() string

type GraphNode 

type GraphNode struct {
	Id     string `json:"id"`
	Name   string `json:"name"`
	Value  int    `json:"val"`
	Color  string `json:"color"`
	Tag    string `json:"tag"`
	Weight int    `json:"weight"`
}

type Heading 

type Heading struct {
	Level int    `json:"level"`
	ID    string `json:"id,omitempty"`
	Text  string `json:"text"`
}

Heading represents a single heading element with its hierarchy level and anchor.

type HierarchySearchProvider 

type HierarchySearchProvider struct {
	// contains filtered or unexported fields
}

func NewHierarchySearchProvider 

func NewHierarchySearchProvider(owner string) (*HierarchySearchProvider, error)

func (*HierarchySearchProvider) Search 

func (p *HierarchySearchProvider) Search(relatedStores []string, embeddingProviderName string, embeddingProviderObj embedding.EmbeddingProvider, modelProviderName string, text string, knowledgeCount int, lang string) ([]Vector, *embedding.EmbeddingResult, error)

type HistogramVecInfo 

type HistogramVecInfo struct {
	Method  string `json:"method"`
	Name    string `json:"name"`
	Count   uint64 `json:"count"`
	Latency string `json:"latency"`
}

type Hospital 

type Hospital struct {
	Owner       string `db:"pk" json:"owner"`
	Name        string `db:"pk" json:"name"`
	CreatedTime string `json:"createdTime"`
	UpdatedTime string `json:"updatedTime"`
	DisplayName string `json:"displayName"`
	Address     string `json:"address"`
}

func GetHospital 

func GetHospital(id string) (*Hospital, error)

func GetHospitals 

func GetHospitals(owner string) ([]*Hospital, error)

func GetMaskedHospital 

func GetMaskedHospital(hospital *Hospital, errs ...error) (*Hospital, error)

func GetMaskedHospitals 

func GetMaskedHospitals(hospitals []*Hospital, errs ...error) ([]*Hospital, error)

func GetPaginationHospitals 

func GetPaginationHospitals(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Hospital, error)

type Image 

type Image struct {
	Owner                   string `db:"pk" json:"owner"`
	Name                    string `db:"pk" json:"name"`
	CreatedTime             string `json:"createdTime"`
	DisplayName             string `json:"displayName"`
	Provider                string `json:"provider"`
	Category                string `json:"category"`
	BootMode                string `json:"bootMode" xml:"bootMode"`
	ImageId                 string `json:"imageId" xml:"imageId"`
	ImageOwnerAlias         string `json:"ImageOwnerAlias" xml:"ImageOwnerAlias"`
	OSName                  string `json:"os" xml:"os"`
	OSNameEn                string `json:"OSNameEn" xml:"OSNameEn"`
	ImageFamily             string `json:"ImageFamily" xml:"ImageFamily"`
	Architecture            string `json:"systemArchitecture" xml:"systemArchitecture"`
	IsSupportIoOptimized    bool   `json:"IsSupportIoOptimized" xml:"IsSupportIoOptimized"`
	Size                    string `json:"size" xml:"size"`
	ResourceGroupId         string `json:"ResourceGroupId" xml:"ResourceGroupId"`
	SupplierName            string `json:"SupplierName" xml:"SupplierName"`
	Description             string `json:"description" xml:"description"`
	Usage                   string `json:"Usage" xml:"Usage"`
	IsCopied                bool   `json:"IsCopied" xml:"IsCopied"`
	LoginAsNonRootSupported bool   `json:"LoginAsNonRootSupported" xml:"LoginAsNonRootSupported"`
	ImageVersion            string `json:"ImageVersion" xml:"ImageVersion"`
	OSType                  string `json:"OSType" xml:"OSType"`
	IsSubscribed            bool   `json:"IsSubscribed" xml:"IsSubscribed"`
	IsSupportCloudinit      bool   `json:"IsSupportCloudinit" xml:"IsSupportCloudinit"`
	CreationTime            string `json:"creationTime" xml:"creationTime"`
	ProductCode             string `json:"ProductCode" xml:"ProductCode"`
	Progress                string `json:"progress" xml:"progress"`
	Platform                string `json:"platform" xml:"platform"`
	IsSelfShared            string `json:"IsSelfShared" xml:"IsSelfShared"`
	ImageName               string `json:"ImageName" xml:"ImageName"`
	Status                  string `json:"state" xml:"state"`
	ImageOwnerId            int64  `json:"ImageOwnerId" xml:"ImageOwnerId"`
	IsPublic                bool   `json:"IsPublic" xml:"IsPublic"`
	// DetectionOptions        DetectionOptions                            `json:"DetectionOptions" xml:"DetectionOptions"`
	// Features                Features                                    `json:"Features" xml:"Features"`
	// Tags                    TagsInDescribeImageFromFamily               `json:"Tags" xml:"Tags"`
	// DiskDeviceMappings      DiskDeviceMappingsInDescribeImageFromFamily `json:"DiskDeviceMappings" xml:"DiskDeviceMappings"`
	// DB info
	RemoteProtocol string `json:"remoteProtocol"`
	RemotePort     int    `json:"remotePort"`
	RemoteUsername string `json:"remoteUsername"`
	RemotePassword string `json:"remotePassword"`
}

func GetImage 

func GetImage(id string) (*Image, error)

func GetImages 

func GetImages(owner string) ([]*Image, error)

func GetMaskedImage 

func GetMaskedImage(image *Image, errs ...error) (*Image, error)

func GetMaskedImages 

func GetMaskedImages(images []*Image, errs ...error) ([]*Image, error)

func GetPaginationImages 

func GetPaginationImages(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Image, error)

func (*Image) GetId 

func (image *Image) GetId() string

type ImageItem 

type ImageItem struct {
	Base64 string `json:"base64"`
	Md5    string `json:"md5"`
}

type ImageMessage 

type ImageMessage struct {
	Url string `json:"url"`
}

type K8sClient 

type K8sClient struct {
	// contains filtered or unexported fields
}

type Label 

type Label struct {
	Id        string  `json:"id"`
	User      string  `json:"user"`
	Type      string  `json:"type"`
	StartTime float64 `json:"startTime"`
	EndTime   float64 `json:"endTime"`
	Text      string  `json:"text"`
	Speaker   string  `json:"speaker"`
	Tag1      string  `json:"tag1"`
	Tag2      string  `json:"tag2"`
	Tag3      string  `json:"tag3"`
}

type Machine 

type Machine struct {
	Owner       string `db:"pk" json:"owner"`
	Name        string `db:"pk" json:"name"`
	Id          string `json:"id"`
	Provider    string `json:"provider"`
	CreatedTime string `json:"createdTime"`
	UpdatedTime string `json:"updatedTime"`
	ExpireTime  string `json:"expireTime"`
	DisplayName string `json:"displayName"`
	Region      string `json:"region"`
	Zone        string `json:"zone"`
	Category    string `json:"category"`
	Type        string `json:"type"`
	Size        string `json:"size"`
	Tag         string `json:"tag"`
	State       string `json:"state"`
	Image       string `json:"image"`
	Os          string `json:"os"`
	PublicIp    string `json:"publicIp"`
	PrivateIp   string `json:"privateIp"`
	CpuSize     string `json:"cpuSize"`
	MemSize     string `json:"memSize"`
	// DB info
	RemoteProtocol string `json:"remoteProtocol"`
	RemotePort     int    `json:"remotePort"`
	RemoteUsername string `json:"remoteUsername"`
	RemotePassword string `json:"remotePassword"`
}

func GetMachine 

func GetMachine(id string) (*Machine, error)

func GetMachines 

func GetMachines(owner string) ([]*Machine, error)

func GetMaskedMachine 

func GetMaskedMachine(machine *Machine, errs ...error) (*Machine, error)

func GetMaskedMachines 

func GetMaskedMachines(machines []*Machine, errs ...error) ([]*Machine, error)

func GetPaginationMachines 

func GetPaginationMachines(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Machine, error)

func (*Machine) GetId 

func (machine *Machine) GetId() string

type Message 

type Message struct {
	Owner             string               `db:"pk" json:"owner"`
	Name              string               `db:"pk" json:"name"`
	CreatedTime       string               `json:"createdTime"`
	Organization      string               `json:"organization"`
	Store             string               `json:"store"`
	User              string               `json:"user"`
	Chat              string               `json:"chat"`
	ReplyTo           string               `json:"replyTo"`
	Author            string               `json:"author"`
	Text              string               `json:"text"`
	ReasonText        string               `json:"reasonText"`
	ErrorText         string               `json:"errorText"`
	FileName          string               `json:"fileName"`
	Comment           string               `json:"comment"`
	TokenCount        int                  `json:"tokenCount"`
	TextTokenCount    int                  `json:"textTokenCount"`
	Price             float64              `json:"price"`
	Currency          string               `json:"currency"`
	IsHidden          bool                 `json:"isHidden"`
	IsDeleted         bool                 `json:"isDeleted"`
	NeedNotify        bool                 `json:"needNotify"`
	IsAlerted         bool                 `json:"isAlerted"`
	IsRegenerated     bool                 `json:"isRegenerated"`
	WebSearchEnabled  bool                 `json:"webSearchEnabled"`
	ModelProvider     string               `json:"modelProvider"`
	EmbeddingProvider string               `json:"embeddingProvider"`
	VectorScores      []VectorScore        `json:"vectorScores"`
	LikeUsers         []string             `json:"likeUsers"`
	DisLikeUsers      []string             `json:"dislikeUsers"`
	Suggestions       []Suggestion         `json:"suggestions"`
	ToolCalls         []model.ToolCall     `json:"toolCalls"`
	SearchResults     []model.SearchResult `json:"searchResults"`
	TransactionId     string               `json:"transactionId"`
}

func GetChatMessages 

func GetChatMessages(chat string) ([]*Message, error)

func GetGlobalFailMessages 

func GetGlobalFailMessages() ([]*Message, error)

func GetGlobalMessages 

func GetGlobalMessages() ([]*Message, error)

func GetGlobalMessagesByStoreName 

func GetGlobalMessagesByStoreName(storeName string) ([]*Message, error)

func GetMessage 

func GetMessage(id string) (*Message, error)

func GetMessages 

func GetMessages(owner string, user string, storeName string) ([]*Message, error)

func GetMessagesForChats 

func GetMessagesForChats(chats []*Chat) ([]*Message, error)

func GetPaginationMessages 

func GetPaginationMessages(owner string, offset, limit int, field, value, sortField, sortOrder, store string) ([]*Message, error)

func (*Message) GetId 

func (message *Message) GetId() string

func (*Message) SendEmail 

func (message *Message) SendEmail(lang string, orgName ...string) error

func (*Message) SendErrorEmail 

func (message *Message) SendErrorEmail(errorText string, lang string, orgName ...string) error

type ModelRoute 

type ModelRoute struct {
	Owner       string  `db:"pk" json:"owner"`     // org ID ("built-in" = global default)
	ModelName   string  `db:"pk" json:"modelName"` // e.g. "claude-sonnet-4-6"
	CreatedTime string  `json:"createdTime"`
	UpdatedTime string  `json:"updatedTime"`
	Provider    string  `json:"provider"`             // primary provider name
	Upstream    string  `json:"upstream"`             // upstream model name
	Fallback1   string  `json:"fallback1Provider"`    // fallback provider 1
	Fallback1Up string  `json:"fallback1Upstream"`    // fallback upstream 1
	Fallback2   string  `json:"fallback2Provider"`    // fallback provider 2
	Fallback2Up string  `json:"fallback2Upstream"`    // fallback upstream 2
	OwnedBy     string  `json:"ownedBy"`              // owned_by override for /api/models listing
	Premium     bool    `json:"premium"`              // requires paid balance
	Hidden      bool    `json:"hidden"`               // excluded from /api/models listing
	InputPrice  float64 `json:"inputPricePerMillion"` // custom pricing (0 = use default)
	OutputPrice float64 `json:"outputPricePerMillion"`
	Enabled     bool    `json:"enabled"`
}

func GetCachedModelRoutes 

func GetCachedModelRoutes(owner string) ([]*ModelRoute, error)

GetCachedModelRoutes returns all model routes for an owner with 60s TTL caching.

func GetModelRoute 

func GetModelRoute(owner string, modelName string) (*ModelRoute, error)

func GetModelRoutes 

func GetModelRoutes(owner string) ([]*ModelRoute, error)

func GetPaginationModelRoutes 

func GetPaginationModelRoutes(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*ModelRoute, error)

func ResolveModelRouteFromDB 

func ResolveModelRouteFromDB(modelName string, orgId string) (*ModelRoute, error)

ResolveModelRouteFromDB looks up a model route from the database. Resolution order: org-specific route -> global ("built-in") route. Returns nil if no DB route found (caller should fall back to YAML).

func (*ModelRoute) GetId 

func (r *ModelRoute) GetId() string

type MsgItem 

type MsgItem struct {
	MsgType string     `json:"msgtype"`
	Image   *ImageItem `json:"image,omitempty"`
}

type MsgResponse 

type MsgResponse struct {
	MsgType string      `json:"msgtype"`
	Stream  *StreamSend `json:"stream"`
}

type MyWriter 

type MyWriter struct {
	bytes.Buffer
}

func (*MyWriter) Flush 

func (w *MyWriter) Flush()

func (*MyWriter) Write 

func (w *MyWriter) Write(p []byte) (n int, err error)

type Node 

type Node struct {
	Owner           string       `db:"pk" json:"owner"`
	Name            string       `db:"pk" json:"name"`
	CreatedTime     string       `json:"createdTime"`
	UpdatedTime     string       `json:"updatedTime"`
	DisplayName     string       `json:"displayName"`
	Description     string       `json:"description"`
	Category        string       `json:"category"`
	Type            string       `json:"type"`
	Tag             string       `json:"tag"`
	MachineName     string       `json:"machineName"`
	Os              string       `json:"os"`
	PublicIp        string       `json:"publicIp"`
	PrivateIp       string       `json:"privateIp"`
	Size            string       `json:"size"`
	CpuSize         string       `json:"cpuSize"`
	MemSize         string       `json:"memSize"`
	RemoteProtocol  string       `json:"remoteProtocol"`
	RemotePort      int          `json:"remotePort"`
	RemoteUsername  string       `json:"remoteUsername"`
	RemotePassword  string       `json:"remotePassword"`
	AutoQuery       bool         `json:"autoQuery"`
	IsPermanent     bool         `json:"isPermanent"`
	Language        string       `json:"language"`
	EnableRemoteApp bool         `json:"enableRemoteApp"`
	RemoteApps      []*RemoteApp `json:"remoteApps"`
	Services        []*Service   `json:"services"`
	Patches         []*Patch     `json:"patches"`
}

func GetMaskedNode 

func GetMaskedNode(node *Node, errs ...error) (*Node, error)

func GetMaskedNodes 

func GetMaskedNodes(nodes []*Node, errs ...error) ([]*Node, error)

func GetNode 

func GetNode(id string) (*Node, error)

func GetNodes 

func GetNodes(owner string) ([]*Node, error)

func GetPaginationNodes 

func GetPaginationNodes(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Node, error)

type Param 

type Param struct {
	Key   string `json:"key"`
	Field string `json:"field"`
	Value string `json:"value"`
}

type Patch 

type Patch struct {
	Name           string `json:"name"`
	Category       string `json:"category"`
	Title          string `json:"title"`
	Url            string `json:"url"`
	Size           string `json:"size"`
	ExpectedStatus string `json:"expectedStatus"`
	Status         string `json:"status"`
	InstallTime    string `json:"installTime"`
	Message        string `json:"message"`
}

type Patient 

type Patient struct {
	Owner        string   `db:"pk" json:"owner"`
	Name         string   `db:"pk" json:"name"`
	CreatedTime  string   `json:"createdTime"`
	UpdatedTime  string   `json:"updatedTime"`
	DisplayName  string   `json:"displayName"`
	Gender       string   `json:"gender"`
	Address      string   `json:"address"`
	Email        string   `json:"email"`
	BloodType    string   `json:"bloodType"`
	Allergies    string   `json:"allergies"`
	Owners       []string `json:"owners"`
	HospitalName string   `json:"hospitalName"`
}

func FilterPatientsByUser 

func FilterPatientsByUser(user *iam.User, patients []*Patient) []*Patient

func GetMaskedPatient 

func GetMaskedPatient(patient *Patient, errs ...error) (*Patient, error)

func GetMaskedPatients 

func GetMaskedPatients(patients []*Patient, errs ...error) ([]*Patient, error)

func GetPaginationPatients 

func GetPaginationPatients(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Patient, error)

func GetPatient 

func GetPatient(id string) (*Patient, error)

func GetPatients 

func GetPatients(owner string) ([]*Patient, error)

type Pod 

type Pod struct {
	Owner       string `db:"pk" json:"owner"`
	Name        string `db:"pk" json:"name"`
	Provider    string `json:"provider"`
	Namespace   string `json:"namespace"`
	CreatedTime string `json:"createdTime"`
	HostIP      string `json:"hostIP"`
	PodIP       string `json:"podIP"`
	Labels      string `json:"labels"`
	Status      string `json:"status"`
}

func GetMaskedPod 

func GetMaskedPod(pod *Pod, errs ...error) (*Pod, error)

func GetMaskedPods 

func GetMaskedPods(pods []*Pod, errs ...error) ([]*Pod, error)

func GetPaginationPods 

func GetPaginationPods(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Pod, error)

func GetPod 

func GetPod(id string) (*Pod, error)

func GetPods 

func GetPods(owner string) ([]*Pod, error)

func (*Pod) GetId 

func (pod *Pod) GetId() string

type PrometheusInfo 

type PrometheusInfo struct {
	ApiThroughput   []GaugeVecInfo     `json:"apiThroughput"`
	ApiLatency      []HistogramVecInfo `json:"apiLatency"`
	TotalThroughput float64            `json:"totalThroughput"`
}

func GetPrometheusInfo 

func GetPrometheusInfo() (*PrometheusInfo, error)

type Properties 

type Properties struct {
	CollectedTime string `json:"collectedTime"`
	Subject       string `json:"subject"`
}

type PropertiesMapJSON 

type PropertiesMapJSON map[string]*Properties

PropertiesMap implements sql.Scanner for map[string]*Properties.

func (*PropertiesMapJSON) Scan 

func (m *PropertiesMapJSON) Scan(src interface{}) error

func (PropertiesMapJSON) Value 

func (m PropertiesMapJSON) Value() (driver.Value, error)

type Provider 

type Provider struct {
	Owner                        string             `db:"pk" json:"owner"`
	Name                         string             `db:"pk" json:"name"`
	CreatedTime                  string             `json:"createdTime"`
	DisplayName                  string             `json:"displayName"`
	Category                     string             `json:"category"`
	Type                         string             `json:"type"`
	SubType                      string             `json:"subType"`
	Flavor                       string             `json:"flavor"`
	ClientId                     string             `json:"clientId"`
	ClientSecret                 string             `json:"clientSecret"`
	Region                       string             `json:"region"`
	ProviderKey                  string             `json:"providerKey"`
	ProviderUrl                  string             `json:"providerUrl"`
	ApiVersion                   string             `json:"apiVersion"`
	CompatibleProvider           string             `json:"compatibleProvider"`
	McpTools                     agent.McpToolsList `json:"mcpTools"`
	Text                         string             `json:"text"`
	ConfigText                   string             `json:"configText"`
	RawText                      string             `json:"rawText"` // Raw result from scan (for Scan category providers)
	EnableThinking               bool               `json:"enableThinking"`
	Temperature                  float32            `json:"temperature"`
	TopP                         float32            `json:"topP"`
	TopK                         int                `json:"topK"`
	FrequencyPenalty             float32            `json:"frequencyPenalty"`
	PresencePenalty              float32            `json:"presencePenalty"`
	InputPricePerThousandTokens  float64            `json:"inputPricePerThousandTokens"`
	OutputPricePerThousandTokens float64            `json:"outputPricePerThousandTokens"`
	Currency                     string             `json:"currency"`
	UserKey                      string             `json:"userKey"`
	UserCert                     string             `json:"userCert"`
	SignKey                      string             `json:"signKey"`
	SignCert                     string             `json:"signCert"`
	ContractName                 string             `json:"contractName"`
	ContractMethod               string             `json:"contractMethod"`
	Network                      string             `json:"network"`
	Chain                        string             `json:"chain"`
	TestContent                  string             `json:"testContent"`
	// New fields for unified scan widget (for Scan category providers)
	TargetMode    string `json:"targetMode"`    // "Manual Input" or "Asset"
	Target        string `json:"target"`        // Manual input target (IP address or network range)
	Asset         string `json:"asset"`         // Selected asset for scan
	Runner        string `json:"runner"`        // Hostname about who runs the scan job
	ErrorText     string `json:"errorText"`     // Error message for the job execution
	ResultSummary string `json:"resultSummary"` // Short summary of scan results
	IsDefault     bool   `json:"isDefault"`
	IsRemote      bool   `json:"isRemote"`
	State         string `json:"state"`
	BrowserUrl    string `json:"browserUrl"`
}

func GetActiveBlockchainProvider 

func GetActiveBlockchainProvider(owner string) (*Provider, error)

func GetAgentProviderFromContext 

func GetAgentProviderFromContext(owner string, name string, lang string) (*Provider, agent.AgentProvider, error)

func GetDefaultAgentProvider 

func GetDefaultAgentProvider() (*Provider, error)

func GetDefaultBlockchainProvider 

func GetDefaultBlockchainProvider() (*Provider, error)

func GetDefaultEmbeddingProvider 

func GetDefaultEmbeddingProvider() (*Provider, error)

func GetDefaultKubernetesProvider 

func GetDefaultKubernetesProvider(lang string) (*Provider, error)

func GetDefaultModelProvider 

func GetDefaultModelProvider() (*Provider, error)

func GetDefaultSpeechToTextProvider 

func GetDefaultSpeechToTextProvider() (*Provider, error)

func GetDefaultStorageProvider 

func GetDefaultStorageProvider() (*Provider, error)

func GetDefaultTextToSpeechProvider 

func GetDefaultTextToSpeechProvider() (*Provider, error)

func GetDefaultVideoProvider 

func GetDefaultVideoProvider() (*Provider, error)

func GetEmbeddingProviderFromContext 

func GetEmbeddingProviderFromContext(owner string, name string, lang string) (*Provider, embedding.EmbeddingProvider, error)

func GetGlobalProviders 

func GetGlobalProviders() ([]*Provider, error)

func GetMaskedProvider 

func GetMaskedProvider(provider *Provider, isMaskEnabled bool, user *iam.User) *Provider

func GetMaskedProviders 

func GetMaskedProviders(providers []*Provider, isMaskEnabled bool, user *iam.User) []*Provider

func GetModelProviderByName 

func GetModelProviderByName(name string) (*Provider, error)

GetModelProviderByName retrieves a Model-category provider by its Name field (e.g. "do-ai", "fireworks", "openai-direct"). Results are cached for 60 seconds.

func GetModelProviderByType 

func GetModelProviderByType(providerType string) (*Provider, error)

GetModelProviderByType retrieves a model provider by its type (e.g. "OpenAI", "Claude", "Fireworks").

func GetModelProviderFromContext 

func GetModelProviderFromContext(owner string, name string, lang string) (*Provider, model.ModelProvider, error)

func GetPaginationProviders 

func GetPaginationProviders(owner, storeName string, offset, limit int, field, value, sortField, sortOrder string) ([]*Provider, error)

func GetProvider 

func GetProvider(id string) (*Provider, error)

func GetProviderByProviderKey 

func GetProviderByProviderKey(providerKey string, lang string) (*Provider, error)

GetProviderByProviderKey retrieves a provider using the Provider key

func GetProviders 

func GetProviders(owner string) ([]*Provider, error)

func (*Provider) GetAgentProvider 

func (p *Provider) GetAgentProvider(lang string) (agent.AgentProvider, error)

func (*Provider) GetEmbeddingProvider 

func (p *Provider) GetEmbeddingProvider(lang string) (embedding.EmbeddingProvider, error)

func (*Provider) GetId 

func (provider *Provider) GetId() string

func (*Provider) GetModelProvider 

func (p *Provider) GetModelProvider(lang string) (model.ModelProvider, error)

func (*Provider) GetScanProvider 

func (p *Provider) GetScanProvider(lang string) (scan.ScanProvider, error)

func (*Provider) GetSpeechToTextProvider 

func (p *Provider) GetSpeechToTextProvider(lang string) (stt.SpeechToTextProvider, error)

func (*Provider) GetStorageProviderObj 

func (p *Provider) GetStorageProviderObj(vectorStoreId string, lang string) (storage.StorageProvider, error)

func (*Provider) GetTextToSpeechProvider 

func (p *Provider) GetTextToSpeechProvider(lang string) (tts.TextToSpeechProvider, error)

type Record 

type Record struct {
	Id           int    `db:"pk" json:"id"`
	Owner        string `json:"owner"`
	Name         string `json:"name"`
	CreatedTime  string `json:"createdTime"`
	Organization string `json:"organization"`
	ClientIp     string `json:"clientIp"`
	UserAgent    string `json:"userAgent"`
	User         string `json:"user"`
	Method       string `json:"method"`
	RequestUri   string `json:"requestUri"`
	Action       string `json:"action"`
	Language     string `json:"language"`
	Query        string `json:"query"`
	Region       string `json:"region"`
	City         string `json:"city"`
	Unit         string `json:"unit"`
	Section      string `json:"section"`
	Object       string `json:"object"`
	Response     string `json:"response"`
	ErrorText    string `json:"errorText"`
	// ExtendedUser *User  `db:"-" json:"extendedUser"`
	Provider     string `json:"provider"`
	Block        string `json:"block"`
	BlockHash    string `json:"blockHash"`
	Transaction  string `json:"transaction"`
	Provider2    string `json:"provider2"`
	Block2       string `json:"block2"`
	BlockHash2   string `json:"blockHash2"`
	Transaction2 string `json:"transaction2"`
	// For cross-chain records
	Count       int  `json:"count"`
	IsTriggered bool `json:"isTriggered"`
	NeedCommit  bool `db:"index" json:"needCommit"`
}

func GetPaginationRecords 

func GetPaginationRecords(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Record, error)

func GetRecord 

func GetRecord(id string, lang string) (*Record, error)

GetRecord retrieves a record by its ID or owner/name format.

func GetRecords 

func GetRecords(owner string) ([]*Record, error)

func NewRecord 

func NewRecord(ctx *context.Context) (*Record, error)

type Remark 

type Remark struct {
	Timestamp string `json:"timestamp"`
	User      string `json:"user"`
	Score     string `json:"score"`
	Text      string `json:"text"`
	IsPublic  bool   `json:"isPublic"`
}

type RemoteApp 

type RemoteApp struct {
	No            int    `json:"no"`
	RemoteAppName string `json:"remoteAppName"`
	RemoteAppDir  string `json:"remoteAppDir"`
	RemoteAppArgs string `json:"remoteAppArgs"`
}

type ResourceMetrics 

type ResourceMetrics struct {
	CPUUsage         string  `json:"cpuUsage"`         // CPU usage (e.g., "120m" for 120 millicores)
	CPUPercentage    float64 `json:"cpuPercentage"`    // CPU usage percentage (0-100)
	MemoryUsage      string  `json:"memoryUsage"`      // Memory usage (e.g., "256Mi" for 256 mebibyte)
	MemoryPercentage float64 `json:"memoryPercentage"` // Memory usage percentage (0-100)
	PodCount         int     `json:"podCount"`         // Number of active pods
}

ResourceMetrics represents resource usage metrics

type ResourceRequests 

type ResourceRequests struct {
	CPU    string `json:"cpu"`
	Memory string `json:"memory"`
}

type Response 

type Response struct {
	Status string `json:"status"`
	Msg    string `json:"msg"`
}

type Scale 

type Scale struct {
	Owner       string `db:"pk" json:"owner"`
	Name        string `db:"pk" json:"name"`
	CreatedTime string `json:"createdTime"`
	DisplayName string `json:"displayName"`
	Text        string `json:"text"`
	State       string `json:"state"`
}

Scale is a reusable rubric / evaluation scale (量表), referenced by tasks via Task.Scale (owner/name id).

func GetGlobalScales 

func GetGlobalScales() ([]*Scale, error)

func GetMaskedScale 

func GetMaskedScale(scale *Scale, isMaskEnabled bool) *Scale

func GetMaskedScales 

func GetMaskedScales(scales []*Scale, isMaskEnabled bool) []*Scale

func GetPaginationScales 

func GetPaginationScales(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Scale, error)

func GetPublicScales 

func GetPublicScales(owner string) ([]*Scale, error)

GetPublicScales returns scales visible to non-admins (Public or empty state).

func GetScale 

func GetScale(id string) (*Scale, error)

func GetScales 

func GetScales(owner string) ([]*Scale, error)

func (*Scale) GetId 

func (s *Scale) GetId() string

type Scan 

type Scan struct {
	Owner         string `db:"pk" json:"owner"`
	Name          string `db:"pk" json:"name"`
	CreatedTime   string `json:"createdTime"`
	UpdatedTime   string `json:"updatedTime"`
	DisplayName   string `json:"displayName"`
	TargetMode    string `json:"targetMode"`
	Target        string `json:"target"`
	Asset         string `json:"asset"`
	Provider      string `json:"provider"`
	State         string `json:"state"`
	Runner        string `json:"runner"`
	ErrorText     string `json:"errorText"`
	Command       string `json:"command"`
	RawResult     string `json:"rawResult"`
	Result        string `json:"result"`
	ResultSummary string `json:"resultSummary"`
}

func GetPaginationScans 

func GetPaginationScans(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Scan, error)

func GetPendingScans 

func GetPendingScans() ([]*Scan, error)

GetPendingScans returns all scans with state "Pending"

func GetScan 

func GetScan(id string) (*Scan, error)

func GetScans 

func GetScans(owner string) ([]*Scan, error)

func GetScansByAsset 

func GetScansByAsset(owner string, assetName string) ([]*Scan, error)

func (*Scan) GetId 

func (scan *Scan) GetId() string

type ScanResult 

type ScanResult struct {
	RawResult     string `json:"rawResult"`
	Result        string `json:"result"`
	ResultSummary string `json:"resultSummary"`
	Runner        string `json:"runner"`
}

ScanResult represents the result of a scan operation

func ScanAsset 

func ScanAsset(provider, scanParam, targetMode, target, asset, command string, saveToScan bool, lang string) (*ScanResult, error)

ScanAsset performs a scan on an asset @param provider: The provider ID (owner/name) for scan provider @param scan: Optional scan ID (owner/name) for saving results to existing scan @param targetMode: "Manual Input" or "Asset" @param target: IP address or network range (for Manual Input mode) @param asset: Asset name for Asset mode @param command: Scan command with optional %s placeholder for target @param saveToScan: Whether to save results to scan object (true for scan edit page, false for provider edit page)

type ScrapeRequest 

type ScrapeRequest struct {
	URL      string `json:"url"`
	Depth    int    `json:"depth,omitempty"`
	MaxPages int    `json:"maxPages,omitempty"`
	Selector string `json:"selector,omitempty"`
	Tag      string `json:"tag,omitempty"`
	Store    string `json:"store,omitempty"`
	Engine   string `json:"engine,omitempty"` // "fast" (Go scraper), "browser" (crawl4ai), or "" (auto)
}

ScrapeRequest is the request body for web scraping operations.

type ScrapeResult 

type ScrapeResult struct {
	URL         string         `json:"url"`
	Title       string         `json:"title"`
	Description string         `json:"description"`
	Content     string         `json:"content"`
	Headings    []Heading      `json:"headings"`
	Links       []string       `json:"links"`
	Structured  StructuredData `json:"structured"`
}

ScrapeResult holds the extracted content from a single page.

func Crawl4AIResultToScrapeResult 

func Crawl4AIResultToScrapeResult(result Crawl4AIResult) ScrapeResult

Crawl4AIResultToScrapeResult converts a Hanzo Crawl result to our ScrapeResult format. It parses the markdown output to extract title, headings, and structured content blocks.

func CrawlSite 

func CrawlSite(req *ScrapeRequest) (results []ScrapeResult, crawlErrors []string, engine string)

CrawlSite performs a crawl starting from req.URL and returns scraped pages. Engine selection:

  • "browser": always use crawl4ai (errors if unavailable)
  • "fast": always use the Go HTML scraper
  • "" (auto): try crawl4ai first, fall back to Go scraper if unreachable

The returned engine string indicates which engine was actually used.

func ScrapePage 

func ScrapePage(pageURL string) (*ScrapeResult, error)

ScrapePage fetches a single URL and extracts structured content.

type ScrapeStats 

type ScrapeStats struct {
	PagesScraped     int      `json:"pagesScraped"`
	DocumentsIndexed int      `json:"documentsIndexed"`
	Engine           string   `json:"engine"`
	Errors           []string `json:"errors,omitempty"`
}

ScrapeStats is the summary returned after a scrape-and-index operation.

func ScrapeAndIndex 

func ScrapeAndIndex(owner string, req *ScrapeRequest, lang string) (*ScrapeStats, error)

ScrapeAndIndex crawls a site and indexes the results into the owner's search index. The owner parameter determines tenant isolation -- each org gets its own index namespace. If Hanzo Storage is configured, crawl results are archived asynchronously for persistence.

type SearchProvider 

type SearchProvider interface {
	Search(relatedStores []string, embeddingProviderName string, embeddingProviderObj embedding.EmbeddingProvider, modelProviderName string, text string, knowledgeCount int, lang string) ([]Vector, *embedding.EmbeddingResult, error)
}

func GetSearchProvider 

func GetSearchProvider(typ string, owner string) (SearchProvider, error)

type Service 

type Service struct {
	No             int    `json:"no"`
	Name           string `json:"name"`
	Path           string `json:"path"`
	Port           int    `json:"port"`
	ProcessId      int    `json:"processId"`
	ExpectedStatus string `json:"expectedStatus"`
	Status         string `json:"status"`
	SubStatus      string `json:"subStatus"`
	Message        string `json:"message"`
}

type ServiceDetail 

type ServiceDetail struct {
	Name         string        `json:"name"`
	Type         string        `json:"type"`
	ClusterIP    string        `json:"clusterIP"`
	ExternalIP   string        `json:"externalIP"`
	Ports        []ServicePort `json:"ports"`
	InternalHost string        `json:"internalHost"`
	ExternalHost string        `json:"externalHost"`
	CreatedTime  string        `json:"createdTime"`
}

type ServicePort 

type ServicePort struct {
	Name     string `json:"name"`
	Port     int32  `json:"port"`
	NodePort int32  `json:"nodePort,omitempty"`
	Protocol string `json:"protocol"`
	URL      string `json:"url,omitempty"`
}

type Session 

type Session struct {
	Owner       string   `db:"pk" json:"owner"`
	Name        string   `db:"pk" json:"name"`
	CreatedTime string   `json:"createdTime"`
	SessionId   []string `json:"sessionId"`
}

func GetPaginationSessions 

func GetPaginationSessions(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Session, error)

func GetSession 

func GetSession(id string) (*Session, error)

func GetSessions 

func GetSessions(owner string) ([]*Session, error)

func (*Session) GetId 

func (session *Session) GetId() string

type SimilarityIndex 

type SimilarityIndex struct {
	Similarity float32
	Index      int
}

type Store 

type Store struct {
	Owner                string              `db:"pk" json:"owner"`
	Name                 string              `db:"pk" json:"name"`
	CreatedTime          string              `json:"createdTime"`
	DisplayName          string              `json:"displayName"`
	StorageProvider      string              `json:"storageProvider"`
	StorageSubpath       string              `json:"storageSubpath"`
	ImageProvider        string              `json:"imageProvider"`
	SplitProvider        string              `json:"splitProvider"`
	SearchProvider       string              `json:"searchProvider"`
	ModelProvider        string              `json:"modelProvider"`
	EmbeddingProvider    string              `json:"embeddingProvider"`
	TextToSpeechProvider string              `json:"textToSpeechProvider"`
	EnableTtsStreaming   bool                `json:"enableTtsStreaming"`
	SpeechToTextProvider string              `json:"speechToTextProvider"`
	AgentProvider        string              `json:"agentProvider"`
	VectorStoreId        string              `json:"vectorStoreId"`
	BuiltinTools         StringSlice         `json:"builtinTools"`
	MemoryLimit          int                 `json:"memoryLimit"`
	Frequency            int                 `json:"frequency"`
	LimitMinutes         int                 `json:"limitMinutes"`
	KnowledgeCount       int                 `json:"knowledgeCount"`
	SuggestionCount      int                 `json:"suggestionCount"`
	Welcome              string              `json:"welcome"`
	WelcomeTitle         string              `json:"welcomeTitle"`
	WelcomeText          string              `json:"welcomeText"`
	Prompt               string              `json:"prompt"`
	ExampleQuestions     ExampleQuestionList `json:"exampleQuestions"`
	ThemeColor           string              `json:"themeColor"`
	Avatar               string              `json:"avatar"`
	Title                string              `json:"title"`
	HtmlTitle            string              `json:"htmlTitle"`
	FaviconUrl           string              `json:"faviconUrl"`
	LogoUrl              string              `json:"logoUrl"`
	FooterHtml           string              `json:"footerHtml"`
	NavItems             StringSlice         `json:"navItems"`
	VectorStores         StringSlice         `json:"vectorStores"`
	ChildStores          StringSlice         `json:"childStores"`
	ChildModelProviders  StringSlice         `json:"childModelProviders"`
	ForbiddenWords       StringSlice         `json:"forbiddenWords"`
	ShowAutoRead         bool                `json:"showAutoRead"`
	DisableFileUpload    bool                `json:"disableFileUpload"`
	HideThinking         bool                `json:"hideThinking"`
	IsDefault            bool                `json:"isDefault"`
	State                string              `json:"state"`
	ChatCount            int                 `db:"-" json:"chatCount"`
	MessageCount         int                 `db:"-" json:"messageCount"`
	FileTree             *TreeFile           `json:"fileTree"`
	PropertiesMap        PropertiesMapJSON   `json:"propertiesMap"`
}

func GetDefaultStore 

func GetDefaultStore(owner string) (*Store, error)

func GetGlobalStores 

func GetGlobalStores() ([]*Store, error)

func GetPaginationStores 

func GetPaginationStores(offset, limit int, name, field, value, sortField, sortOrder string) ([]*Store, error)

func GetStore 

func GetStore(id string) (*Store, error)

func GetStores 

func GetStores(owner string) ([]*Store, error)

func GetStoresByFields 

func GetStoresByFields(owner string, fields ...string) ([]*Store, error)

func (*Store) ContainsForbiddenWords 

func (store *Store) ContainsForbiddenWords(text string) (bool, string)

func (*Store) GetEmbeddingProvider 

func (store *Store) GetEmbeddingProvider() (*Provider, error)

func (*Store) GetId 

func (store *Store) GetId() string

func (*Store) GetImageProviderObj 

func (store *Store) GetImageProviderObj(lang string) (storage.StorageProvider, error)

func (*Store) GetModelProvider 

func (store *Store) GetModelProvider() (*Provider, error)

func (*Store) GetSpeechToTextProvider 

func (store *Store) GetSpeechToTextProvider() (*Provider, error)

func (*Store) GetStorageProviderObj 

func (store *Store) GetStorageProviderObj(lang string) (storage.StorageProvider, error)

func (*Store) GetTextToSpeechProvider 

func (store *Store) GetTextToSpeechProvider() (*Provider, error)

func (*Store) GetVideoData 

func (store *Store) GetVideoData(lang string) ([]string, error)

func (*Store) Populate 

func (store *Store) Populate(origin string, lang string) error

type StreamRecv 

type StreamRecv struct {
	Id string `json:"id"`
}

type StreamResponse 

type StreamResponse struct {
	MsgType string      `json:"msgtype"`
	Stream  *StreamSend `json:"stream"`
}

type StreamSend 

type StreamSend struct {
	ID      string    `json:"id,omitempty"`
	Finish  bool      `json:"finish"`
	Content string    `json:"content,omitempty"`
	MsgItem []MsgItem `json:"msg_item,omitempty"`
}

type StringSlice 

type StringSlice []string

StringSlice is []string with JSON marshalling for SQL TEXT columns.

func (*StringSlice) Scan 

func (s *StringSlice) Scan(src interface{}) error

func (StringSlice) Value 

func (s StringSlice) Value() (driver.Value, error)

type StructuredData 

type StructuredData struct {
	Headings []Heading      `json:"headings"`
	Contents []ContentBlock `json:"contents"`
}

StructuredData mirrors the docs framework format for search indexing.

type SubpathStorageProvider 

type SubpathStorageProvider struct {
	// contains filtered or unexported fields
}

func NewSubpathStorageProvider 

func NewSubpathStorageProvider(provider storage.StorageProvider, subpath string) *SubpathStorageProvider

func (*SubpathStorageProvider) DeleteObject 

func (w *SubpathStorageProvider) DeleteObject(key string) error

func (*SubpathStorageProvider) ListObjects 

func (w *SubpathStorageProvider) ListObjects(prefix string) ([]*storage.Object, error)

ListObjects Implements the StorageProvider interface, automatically prepending the subpath prefix in each method

func (*SubpathStorageProvider) PutObject 

func (w *SubpathStorageProvider) PutObject(user string, parent string, key string, fileBuffer *bytes.Buffer) (string, error)

type Suggestion 

type Suggestion struct {
	Text  string `json:"text"`
	IsHit bool   `json:"isHit"`
}

type Task 

type Task struct {
	Owner        string   `db:"pk" json:"owner"`
	Name         string   `db:"pk" json:"name"`
	CreatedTime  string   `json:"createdTime"`
	DisplayName  string   `json:"displayName"`
	Provider     string   `json:"provider"`
	Type         string   `json:"type"`
	Subject      string   `json:"subject"`
	Topic        string   `json:"topic"`
	Score        float64  `json:"score"`
	Activity     string   `json:"activity"`
	Grade        string   `json:"grade"`
	Path         string   `json:"path"`
	Scale        string   `json:"scale"`
	Example      string   `json:"example"`
	Labels       []string `json:"labels"`
	Log          string   `json:"log"`
	Result       string   `json:"result"`
	DocumentUrl  string   `json:"documentUrl"`
	DocumentText string   `json:"documentText"`
}

func GetGlobalTasks 

func GetGlobalTasks(owner string) ([]*Task, error)

func GetMaskedTask 

func GetMaskedTask(task *Task, isMaskEnabled bool) *Task

func GetMaskedTasks 

func GetMaskedTasks(tasks []*Task, isMaskEnabled bool) []*Task

func GetPaginationTasks 

func GetPaginationTasks(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Task, error)

func GetTask 

func GetTask(id string) (*Task, error)

func GetTasks 

func GetTasks(owner string) ([]*Task, error)

func (*Task) GetId 

func (task *Task) GetId() string

type TaskResult 

type TaskResult struct {
	Title         string                `json:"title"`
	Designer      string                `json:"designer"`
	Stage         string                `json:"stage"`
	Participants  string                `json:"participants"`
	Grade         string                `json:"grade"`
	Instructor    string                `json:"instructor"`
	Subject       string                `json:"subject"`
	School        string                `json:"school"`
	OtherSubjects string                `json:"otherSubjects"`
	Textbook      string                `json:"textbook"`
	Score         float64               `json:"score"`
	Categories    []*TaskResultCategory `json:"categories"`
}

func AnalyzeTask 

func AnalyzeTask(task *Task, lang string) (*TaskResult, error)

type TaskResultCategory 

type TaskResultCategory struct {
	Name  string            `json:"name"`
	Score float64           `json:"score"`
	Items []*TaskResultItem `json:"items"`
}

type TaskResultItem 

type TaskResultItem struct {
	Name         string  `json:"name"`
	Score        float64 `json:"score"`
	Advantage    string  `json:"advantage"`
	Disadvantage string  `json:"disadvantage"`
	Suggestion   string  `json:"suggestion"`
}

type Template 

type Template struct {
	Owner              string                 `db:"pk" json:"owner"`
	Name               string                 `db:"pk" json:"name"`
	CreatedTime        string                 `json:"createdTime"`
	UpdatedTime        string                 `json:"updatedTime"`
	DisplayName        string                 `json:"displayName"`
	Description        string                 `json:"description"`
	Version            string                 `json:"version"`
	Icon               string                 `json:"icon"`
	Manifest           string                 `json:"manifest"`
	Readme             string                 `json:"readme"`
	EnableBasicConfig  bool                   `json:"enableBasicConfig"`
	BasicConfigOptions []templateConfigOption `db:"json" json:"basicConfigOptions"`
}

func GetPaginationTemplates 

func GetPaginationTemplates(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Template, error)

func GetTemplate 

func GetTemplate(id string) (*Template, error)

func GetTemplates 

func GetTemplates(owner string) ([]*Template, error)

func (*Template) Render 

func (t *Template) Render(data map[string]interface{}) (string, error)

Render the template with the given data.

type TextMessage 

type TextMessage struct {
	Content string `json:"content"`
}

type TreeFile 

type TreeFile struct {
	Key         string               `json:"key"`
	Title       string               `json:"title"`
	Size        int64                `json:"size"`
	CreatedTime string               `json:"createdTime"`
	IsLeaf      bool                 `json:"isLeaf"`
	Url         string               `json:"url"`
	Children    []*TreeFile          `json:"children"`
	ChildrenMap map[string]*TreeFile `db:"-" json:"-"`
}

func (*TreeFile) Scan 

func (t *TreeFile) Scan(src interface{}) error

Scan on *TreeFile so Store.FileTree round-trips JSON<->struct.

func (*TreeFile) Value 

func (t *TreeFile) Value() (driver.Value, error)

type TxtLabel 

type TxtLabel struct {
	Type      string  `json:"type"`
	StartTime float64 `json:"startTime"`
	EndTime   float64 `json:"endTime"`
	Speaker   string  `json:"speaker"`
	Text      string  `json:"text"`
}

type Usage 

type Usage struct {
	Date         string  `json:"date"`
	UserCount    int     `json:"userCount"`
	ChatCount    int     `json:"chatCount"`
	MessageCount int     `json:"messageCount"`
	TokenCount   int     `json:"tokenCount"`
	Price        float64 `json:"price"`
	Currency     string  `json:"currency"`
}

func GetRangeUsages 

func GetRangeUsages(rangeType string, count int, user string, storeName string, lang string) ([]*Usage, error)

func GetUsage 

func GetUsage(date string) (*Usage, error)

func GetUsages 

func GetUsages(days int, user string, storeName string) ([]*Usage, error)

type UsageInfo 

type UsageInfo struct {
	Provider   string    `json:"provider"`
	TokenCount int       `json:"tokenCount"`
	StartTime  time.Time `json:"startTime"`
}

type UsageMetadata 

type UsageMetadata struct {
	Organization string `json:"organization"`
	Application  string `json:"application"`
}

func GetUsageMetadata 

func GetUsageMetadata(lang string, orgName ...string) (*UsageMetadata, error)

type UserUsage 

type UserUsage struct {
	User         string  `json:"user"`
	Chats        int     `json:"chats"`
	MessageCount int     `json:"messageCount"`
	TokenCount   int     `json:"tokenCount"`
	Price        float64 `json:"price"`
}

func GetUserTableInfos 

func GetUserTableInfos(storeName, user string) ([]*UserUsage, error)

type Vector 

type Vector struct {
	Owner       string    `db:"pk" json:"owner"`
	Name        string    `db:"pk" json:"name"`
	CreatedTime string    `json:"createdTime"`
	DisplayName string    `json:"displayName"`
	Store       string    `json:"store"`
	Provider    string    `json:"provider"`
	File        string    `json:"file"`
	Index       int       `json:"index"`
	Text        string    `json:"text"`
	TokenCount  int       `json:"tokenCount"`
	Price       float64   `json:"price"`
	Currency    string    `json:"currency"`
	Score       float32   `json:"score"`
	Data        []float32 `json:"data"`
	Dimension   int       `json:"dimension"`
}

func GetGlobalVectors 

func GetGlobalVectors() ([]*Vector, error)

func GetPaginationVectors 

func GetPaginationVectors(owner string, storeName string, offset, limit int, field, value, sortField, sortOrder string) ([]*Vector, error)

func GetVector 

func GetVector(id string) (*Vector, error)

func GetVectors 

func GetVectors(owner string) ([]*Vector, error)

func (*Vector) GetId 

func (vector *Vector) GetId() string

type VectorScore 

type VectorScore struct {
	Vector string  `json:"vector"`
	Score  float32 `json:"score"`
}

func GetNearestKnowledge 

func GetNearestKnowledge(storeName string, vectorStores []string, searchProviderType string, embeddingProvider *Provider, embeddingProviderObj embedding.EmbeddingProvider, modelProvider *Provider, owner string, text string, knowledgeCount int, lang string) ([]*model.RawMessage, []VectorScore, *embedding.EmbeddingResult, error)

type Video 

type Video struct {
	Owner          string         `db:"pk" json:"owner"`
	Name           string         `db:"pk" json:"name"`
	CreatedTime    string         `json:"createdTime"`
	DisplayName    string         `json:"displayName"`
	Description    string         `json:"description"`
	Tag            string         `json:"tag"`
	Type           string         `json:"type"`
	VideoId        string         `json:"videoId"`
	VideoLength    string         `json:"videoLength"`
	CoverUrl       string         `json:"coverUrl"`
	DownloadUrl    string         `json:"downloadUrl"`
	AudioUrl       string         `json:"audioUrl"`
	EditMode       string         `json:"editMode"`
	Labels         []*Label       `json:"labels"`
	Segments       []*Label       `json:"segments"`
	LabelCount     int            `db:"-" json:"labelCount"`
	SegmentCount   int            `db:"-" json:"segmentCount"`
	WordCountMap   map[string]int `json:"wordCountMap"`
	DataUrls       []string       `json:"dataUrls"`
	DataUrl        string         `json:"dataUrl"`
	TagOnPause     bool           `json:"tagOnPause"`
	Remarks        []*Remark      `json:"remarks"`
	Remarks2       []*Remark      `json:"remarks2"`
	ExcellentCount int            `json:"excellentCount"`
	State          string         `json:"state"`
	ReviewState    string         `json:"reviewState"`
	IsPublic       bool           `json:"isPublic"`
	School         string         `json:"school"`
	Stage          string         `json:"stage"`
	Grade          string         `json:"grade"`
	Unit           string         `json:"unit"`
	Lesson         string         `json:"lesson"`
	Class          string         `json:"class"`
	Subject        string         `json:"subject"`
	Topic          string         `json:"topic"`
	Grade2         string         `json:"grade2"`
	Keywords       []string       `json:"keywords"`
	Template       string         `json:"template"`
	Task1          string         `json:"task1"`
	Task2          string         `json:"task2"`
	Task3          string         `json:"task3"`
	PlayAuth       string         `db:"-" json:"playAuth"`
}

func GetGlobalVideos 

func GetGlobalVideos() ([]*Video, error)

func GetPaginationVideos 

func GetPaginationVideos(owner string, offset int, limit int, field string, value string, sortField string, sortOrder string, lang string) ([]*Video, error)

func GetVideo 

func GetVideo(id string, lang string) (*Video, error)

func GetVideos 

func GetVideos(owner string, lang string) ([]*Video, error)

func (*Video) GetId 

func (video *Video) GetId() string

func (*Video) Populate 

func (video *Video) Populate(lang string) error

func (*Video) PopulateWordCountMap 

func (v *Video) PopulateWordCountMap(lang string) error

type VpcDetail 

type VpcDetail struct {
	VpcId       string
	CidrBlock   string
	VRouterId   string
	IsDefault   bool
	Status      string
	Description string
}

VpcDetail holds detailed information for a VPC

type WecomBotMessage 

type WecomBotMessage struct {
	MsgId    string        `json:"msgid"`
	AIBotId  string        `json:"aibotid"`
	ChatId   string        `json:"chatid,omitempty"`
	ChatType string        `json:"chattype"`
	From     *FromUser     `json:"from"`
	MsgType  string        `json:"msgtype"`
	Text     *TextMessage  `json:"text,omitempty"`
	Image    *ImageMessage `json:"image,omitempty"`
	Stream   *StreamRecv   `json:"stream,omitempty"`
}

type Workflow 

type Workflow struct {
	Owner       string `db:"pk" json:"owner"`
	Name        string `db:"pk" json:"name"`
	CreatedTime string `json:"createdTime"`
	DisplayName string `json:"displayName"`

	Text             string `json:"text"`
	Text2            string `json:"text2"`
	Message          string `json:"message"`
	QuestionTemplate string `json:"questionTemplate"`
}

func GetGlobalWorkflows 

func GetGlobalWorkflows() ([]*Workflow, error)

func GetMaskedWorkflow 

func GetMaskedWorkflow(workflow *Workflow, isMaskEnabled bool) *Workflow

func GetMaskedWorkflows 

func GetMaskedWorkflows(workflows []*Workflow, isMaskEnabled bool) []*Workflow

func GetPaginationWorkflows 

func GetPaginationWorkflows(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Workflow, error)

func GetWorkflow 

func GetWorkflow(id string) (*Workflow, error)

func GetWorkflows 

func GetWorkflows(owner string) ([]*Workflow, error)

func (*Workflow) GetId 

func (workflow *Workflow) GetId() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.