h2ogpte 1.6.42__py3-none-any.whl → 1.6.43__py3-none-any.whl

h2ogpte/h2ogpte_async.py

@@ -10,7 +10,7 @@ import json
 import time
 import uuid
 from pathlib import Path
-from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
+from typing import Any, Dict, Iterable, List, Optional, Tuple, Union, Callable
 from collections import defaultdict
 from h2o_authn import AsyncTokenProvider
 from urllib.parse import quote
@@ -89,6 +89,7 @@ from h2ogpte.connectors import (
     GCSServiceAccountCredential,
     AzureKeyCredential,
     AzureSASCredential,
+    ConfluenceCredential,
 )
 
 
@@ -170,6 +171,7 @@ class H2OGPTEAsync:
             self.configuration_api = None
             self.agent_api = None
             self.secrets_api = None
+            self.extractor_api = None
 
         async def __aenter__(self):
             if not self._h2ogpte._version_checked:
@@ -296,19 +298,67 @@ class H2OGPTEAsync:
                 Default value is to use the first model (0th index).
             llm_args:
                 Dictionary of kwargs to pass to the llm. Valid keys:
+                    # Core generation parameters
                     temperature (float, default: 0) — The value used to modulate the next token probabilities. Most deterministic: 0, Most creative: 1
-                    seed (int, default: 0) — The seed for the random number generator, only used if temperature > 0, seed=0 will pick a random number for each call, seed > 0 will be fixed.
-                    top_k (int, default: 1) — The number of highest probability vocabulary tokens to keep for top-k-filtering.
-                    top_p (float, default: 1.0) — If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation.
-                    repetition_penalty (float, default: 1.07) — The parameter for repetition penalty. 1.0 means no penalty.
-                    max_new_tokens (int, default: 1024) — Maximum number of new tokens to generate. This limit applies to each (map+reduce) step during summarization and each (map) step during extraction.
-                    min_max_new_tokens (int, default: 512) — minimum value for max_new_tokens when auto-adjusting for content of prompt, docs, etc.
-                    response_format (str, default: "text") — Output type, one of ["text", "json_object", "json_code"].
-                    guided_json (dict, default: None) — If specified, the output will follow the JSON schema.
-                    guided_regex (str, default: "") — If specified, the output will follow the regex pattern. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_choice (Optional[List[str]], default: None — If specified, the output will be exactly one of the choices. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_grammar (str, default: "") — If specified, the output will follow the context free grammar. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_whitespace_pattern (str, default: "") — If specified, will override the default whitespace pattern for guided json decoding. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
+                    seed (int, default: 0) — The seed for the random number generator, only used if temperature > 0, seed=0 will pick a random number for each call, seed > 0 will be fixed
+                    top_k (int, default: 1) — The number of highest probability vocabulary tokens to keep for top-k-filtering
+                    top_p (float, default: 1.0) — If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation
+                    repetition_penalty (float, default: 1.07) — The parameter for repetition penalty. 1.0 means no penalty
+                    max_new_tokens (int, default: 1024) — Maximum number of new tokens to generate. This limit applies to each (map+reduce) step during summarization and each (map) step during extraction
+                    min_max_new_tokens (int, default: 512) — Minimum value for max_new_tokens when auto-adjusting for content of prompt, docs, etc.
+                    min_chars_per_yield (int) — Minimum number of characters to yield at a time during streaming
+                    reasoning_effort (int, default: 0) — Level of reasoning effort for the model (higher values = deeper reasoning, e.g., 10000-65000). Use for models that support chain-of-thought reasoning. 0 means no additional reasoning effort
+
+                    # Output format parameters
+                    response_format (str, default: "text") — Output type, one of ["text", "json_object", "json_code"]
+                    guided_json (dict, default: None) — If specified, the output will follow the JSON schema
+                    guided_regex (str, default: "") — If specified, the output will follow the regex pattern. Only for models that support guided generation: check output of get_llms() for guided_vllm flag
+                    guided_choice (Optional[List[str]], default: None) — If specified, the output will be exactly one of the choices. Only for models that support guided generation
+                    guided_grammar (str, default: "") — If specified, the output will follow the context free grammar. Only for models that support guided generation
+                    guided_whitespace_pattern (str, default: "") — If specified, will override the default whitespace pattern for guided json decoding. Only for models that support guided generation
+                    json_preserve_system_prompt (bool) — Whether to preserve the system prompt when using JSON response format
+
+                    # Vision and image parameters
+                    images_num_max (int) — Maximum number of images to process
+                    visible_vision_models (list) — List of vision models that can be used
+
+                    # Agent parameters
+                    use_agent (bool, default: False) — Whether to enable agent functionality for advanced task processing with access to tools
+                    shared_agent (bool, default: False) — Whether to use shared agent instance across multiple requests for efficiency
+                    agent_type (str, default: "auto") — Type of agent to use. Options: ["auto", "agent_analysis", "agent_chat_history_md", "agent_code", "agent_rag"]
+                    selected_tool_type (str, default: "auto") — Type of tools to make available to the agent. Options: ["auto", "all", "any"] or specific tool names
+                    agent_accuracy (str, default: "standard") — Accuracy level for agent operations. Options:
+                        "quick" - Fastest, less verification (max_turns=10, timeout=30s)
+                        "basic" - Best for simple tasks (max_turns=20, timeout=60s)
+                        "standard" - Good for most tasks (max_turns=40, timeout=120s)
+                        "maximum" - Highest accuracy, can take a long time (max_turns=80, timeout=240s)
+                    agent_max_turns (Union[str, int], default: "auto") — Maximum number of back-and-forth turns the agent can take. Either "auto" or an integer
+                    agent_original_files (list) — List of file paths for agent to process and analyze
+                    agent_timeout (int) — Timeout in seconds for each individual agent turn/operation
+                    agent_total_timeout (int, default: 3600) — Total timeout in seconds for all agent operations combined
+                    agent_min_time (int) — Minimum time in seconds to run the agent before allowing completion
+                    agent_tools (Union[str, list], default: "auto") — List of specific tools available to the agent. Options: "auto", "all", "any", or list of tool names
+                    user_persona (str) — User persona description for agent context to customize agent behavior
+                    agent_code_writer_system_message (str) — Custom system message for code writing agent to guide code generation
+                    agent_code_restrictions_level (int) — Level of code execution restrictions for agent (typically 0 for unrestricted)
+                    agent_num_executable_code_blocks_limit (int) — Maximum number of code blocks the agent can execute in a single session
+                    agent_system_site_packages (bool, default: False) — Whether agent can use system site packages when executing code
+                    agent_main_model (str) — Main model to use for agent operations (e.g., specific LLM name)
+                    agent_max_stream_length (int, default: -1) — Maximum length for agent streaming responses, -1 for unlimited
+                    agent_max_memory_usage (int) — Maximum memory usage in bytes for agent operations
+                    agent_main_reasoning_effort (int) — Level of reasoning effort for main agent model (higher values = more reasoning, e.g., 10000)
+                    agent_advanced_reasoning_effort (int) — Level of reasoning effort for advanced agent operations (e.g., 20000)
+                    agent_max_confidence_level (int) — Maximum confidence level for agent decisions (typically 0, 1, or 2)
+                    agent_planning_forced_mode (bool) — Whether to force planning mode for agent (True to always plan first)
+                    agent_too_soon_forced_mode (bool) — Whether to force handling of premature agent decisions
+                    agent_critique_forced_mode (int) — Whether to force critique mode for agent self-evaluation
+                    agent_query_understanding_parallel_calls (int) — Number of parallel calls for query understanding
+                    tool_building_mode (str) — Mode for tool building configuration
+                    agent_stream_files (bool, default: True) — Whether to stream files from agent operations for real-time updates
+
+                    # Other parameters
+                    max_time (int) — Maximum time in seconds for the operation
+                    client_metadata (dict) — Metadata to include with the request
             chat_conversation:
                 List of tuples for (human, bot) conversation that will be pre-appended
                 to an (question, None) case for a query.
@@ -420,18 +470,19 @@ class H2OGPTEAsync:
             llm_args:
                 Dictionary of kwargs to pass to the llm. Valid keys:
                     temperature (float, default: 0) — The value used to modulate the next token probabilities. Most deterministic: 0, Most creative: 1
-                    seed (int, default: 0) — The seed for the random number generator, only used if temperature > 0, seed=0 will pick a random number for each call, seed > 0 will be fixed.
-                    top_k (int, default: 1) — The number of highest probability vocabulary tokens to keep for top-k-filtering.
-                    top_p (float, default: 1.0) — If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation.
-                    repetition_penalty (float, default: 1.07) — The parameter for repetition penalty. 1.0 means no penalty.
-                    max_new_tokens (int, default: 1024) — Maximum number of new tokens to generate. This limit applies to each (map+reduce) step during summarization and each (map) step during extraction.
-                    min_max_new_tokens (int, default: 512) — minimum value for max_new_tokens when auto-adjusting for content of prompt, docs, etc.
-                    response_format (str, default: "text") — Output type, one of ["text", "json_object", "json_code"].
-                    guided_json (dict, default: None) — If specified, the output will follow the JSON schema.
-                    guided_regex (str, default: "") — If specified, the output will follow the regex pattern. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_choice (Optional[List[str]], default: None — If specified, the output will be exactly one of the choices. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_grammar (str, default: "") — If specified, the output will follow the context free grammar. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_whitespace_pattern (str, default: "") — If specified, will override the default whitespace pattern for guided json decoding. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
+                    seed (int, default: 0) — The seed for the random number generator, only used if temperature > 0, seed=0 will pick a random number for each call, seed > 0 will be fixed
+                    top_k (int, default: 1) — The number of highest probability vocabulary tokens to keep for top-k-filtering
+                    top_p (float, default: 1.0) — If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation
+                    repetition_penalty (float, default: 1.07) — The parameter for repetition penalty. 1.0 means no penalty
+                    max_new_tokens (int, default: 1024) — Maximum number of new tokens to generate. This limit applies to each (map+reduce) step during summarization and each (map) step during extraction
+                    min_max_new_tokens (int, default: 512) — Minimum value for max_new_tokens when auto-adjusting for content of prompt, docs, etc.
+                    reasoning_effort (int, default: 0) — Level of reasoning effort for the model (higher values = deeper reasoning, e.g., 10000-65000). Use for models that support chain-of-thought reasoning. 0 means no additional reasoning effort
+                    response_format (str, default: "text") — Output type, one of ["text", "json_object", "json_code"]
+                    guided_json (dict, default: None) — If specified, the output will follow the JSON schema
+                    guided_regex (str, default: "") — If specified, the output will follow the regex pattern. Only for models that support guided generation
+                    guided_choice (Optional[List[str]], default: None) — If specified, the output will be exactly one of the choices. Only for models that support guided generation
+                    guided_grammar (str, default: "") — If specified, the output will follow the context free grammar. Only for models that support guided generation
+                    guided_whitespace_pattern (str, default: "") — If specified, will override the default whitespace pattern for guided json decoding. Only for models that support guided generation
             guardrails_settings:
                 Guardrails Settings.
             timeout:
@@ -530,18 +581,19 @@ class H2OGPTEAsync:
             llm_args:
                 Dictionary of kwargs to pass to the llm. Valid keys:
                     temperature (float, default: 0) — The value used to modulate the next token probabilities. Most deterministic: 0, Most creative: 1
-                    seed (int, default: 0) — The seed for the random number generator, only used if temperature > 0, seed=0 will pick a random number for each call, seed > 0 will be fixed.
-                    top_k (int, default: 1) — The number of highest probability vocabulary tokens to keep for top-k-filtering.
-                    top_p (float, default: 1.0) — If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation.
-                    repetition_penalty (float, default: 1.07) — The parameter for repetition penalty. 1.0 means no penalty.
-                    max_new_tokens (int, default: 1024) — Maximum number of new tokens to generate. This limit applies to each (map+reduce) step during summarization and each (map) step during extraction.
-                    min_max_new_tokens (int, default: 512) — minimum value for max_new_tokens when auto-adjusting for content of prompt, docs, etc.
-                    response_format (str, default: "text") — Output type, one of ["text", "json_object", "json_code"].
-                    guided_json (dict, default: None) — If specified, the output will follow the JSON schema.
-                    guided_regex (str, default: "") — If specified, the output will follow the regex pattern. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_choice (Optional[List[str]], default: None — If specified, the output will be exactly one of the choices. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_grammar (str, default: "") — If specified, the output will follow the context free grammar. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_whitespace_pattern (str, default: "") — If specified, will override the default whitespace pattern for guided json decoding. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
+                    seed (int, default: 0) — The seed for the random number generator, only used if temperature > 0, seed=0 will pick a random number for each call, seed > 0 will be fixed
+                    top_k (int, default: 1) — The number of highest probability vocabulary tokens to keep for top-k-filtering
+                    top_p (float, default: 1.0) — If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation
+                    repetition_penalty (float, default: 1.07) — The parameter for repetition penalty. 1.0 means no penalty
+                    max_new_tokens (int, default: 1024) — Maximum number of new tokens to generate. This limit applies to each (map+reduce) step during summarization and each (map) step during extraction
+                    min_max_new_tokens (int, default: 512) — Minimum value for max_new_tokens when auto-adjusting for content of prompt, docs, etc.
+                    reasoning_effort (int, default: 0) — Level of reasoning effort for the model (higher values = deeper reasoning, e.g., 10000-65000). Use for models that support chain-of-thought reasoning. 0 means no additional reasoning effort
+                    response_format (str, default: "text") — Output type, one of ["text", "json_object", "json_code"]
+                    guided_json (dict, default: None) — If specified, the output will follow the JSON schema
+                    guided_regex (str, default: "") — If specified, the output will follow the regex pattern. Only for models that support guided generation
+                    guided_choice (Optional[List[str]], default: None) — If specified, the output will be exactly one of the choices. Only for models that support guided generation
+                    guided_grammar (str, default: "") — If specified, the output will follow the context free grammar. Only for models that support guided generation
+                    guided_whitespace_pattern (str, default: "") — If specified, will override the default whitespace pattern for guided json decoding. Only for models that support guided generation
             guardrails_settings:
                 Guardrails Settings.
             timeout:
@@ -849,13 +901,18 @@ class H2OGPTEAsync:
         )
         return result
 
-    async def create_chat_session(self, collection_id: Optional[str] = None) -> str:
+    async def create_chat_session(
+        self, collection_id: Optional[str] = None, workspace: Optional[str] = None
+    ) -> str:
         """Creates a new chat session for asking questions (of documents).
 
         Args:
             collection_id:
                 String id of the collection to chat with.
                 If None, chat with LLM directly.
+            workspace:
+                String id of the workspace this chat will be associated with.
+                If None, the user's default workspace will be used.
 
         Returns:
             str: The ID of the newly created chat session.
@@ -864,7 +921,11 @@ class H2OGPTEAsync:
         async with self._RESTClient(self) as rest_client:
             response = await _rest_to_client_exceptions(
                 rest_client.chat_api.create_chat_session(
-                    collection_id=collection_id, _headers=header
+                    collection_id=collection_id,
+                    create_chat_session_request=rest.CreateChatSessionRequest(
+                        workspace=workspace,
+                    ),
+                    _headers=header,
                 )
             )
             return response.id
@@ -879,7 +940,8 @@ class H2OGPTEAsync:
         async with self._RESTClient(self) as rest_client:
             response = await _rest_to_client_exceptions(
                 rest_client.chat_api.create_chat_session(
-                    collection_id="default", _headers=header
+                    collection_id="default",
+                    _headers=header,
                 )
             )
         return response.id
@@ -966,6 +1028,7 @@ class H2OGPTEAsync:
         collection_settings: Union[dict, None] = None,
         thumbnail: Union[Path, None] = None,
         chat_settings: Union[dict, None] = None,
+        workspace: Union[str, None] = None,
     ) -> str:
         r"""Creates a new collection.
 
@@ -1012,8 +1075,8 @@ class H2OGPTEAsync:
                     guardrails_labels_to_flag: list of entities to be flagged as safety violations in user prompts. Must be a subset of guardrails_entities, if provided.
                     guardrails_safe_category: (Optional) name of the safe category for guardrails. Must be a key in guardrails_entities, if provided. Otherwise uses system defaults.
                     guardrails_entities: (Optional) dictionary of entities and their descriptions for the guardrails model to classify. The first entry is the "safe" class, the rest are "unsafe" classes.
-                    column_redaction_custom_entities_to_flag: list of entities to redact in tabular data files. Must be a subset of column_redaction_custom_entities, if provided.
-                    column_redaction_custom_entities: (Optional) dictionary of entities and a short description for the LLM to check for and redact columns containing PII in tabular data files.
+                    custom_pii_entities_to_flag: list of entities to redact in tabular data files. Must be a subset of custom_pii_entities, if provided.
+                    custom_pii_entities: (Optional) dictionary of entities and a short description for the LLM to check for and redact columns containing PII in tabular data files.
                     guardrails_llm: LLM to use for guardrails and PII detection. Use "auto" for automatic. Use `H2OGPTE.get_llms()` to see all available options.
                 Example:
                     Note: Call client.get_guardrails_settings() to see all options for guardrails_settings.
@@ -1045,10 +1108,10 @@ class H2OGPTEAsync:
                                 "Intellectual Property": "Messages that may violate the intellectual property rights of any third party",
                                 "Code Interpreter Abuse": "Messages that seek to abuse code interpreters, including those that enable denial of service attacks, container escapes or privilege escalation exploits",
                             },
-                            column_redaction_custom_entities_to_flag=[
+                            custom_pii_entities_to_flag=[
                                 "Mother's Maiden Name"
                             ],
-                            column_redaction_custom_entities={
+                            custom_pii_entities={
                                 "Mother's Maiden Name": "Mother's maiden name."
                             },
                             guardrails_llm="meta-llama/Llama-3.3-70B-Instruct",
@@ -1059,12 +1122,14 @@ class H2OGPTEAsync:
             chat_settings:
                 (Optional) Dictionary with key/value pairs to configure the default values for certain chat specific settings
                 The following keys are supported, see the client.session() documentation for more details.
-                llm: str
-                llm_args: dict
-                self_reflection_config: dict
-                rag_config: dict
-                include_chat_history: bool
-                tags: list[str]
+                llm: str — Default LLM to use for chat sessions in this collection
+                llm_args: dict — Default LLM arguments (see answer_question method for full list of valid keys)
+                self_reflection_config: dict — Configuration for self-reflection functionality
+                rag_config: dict — Configuration for RAG (Retrieval-Augmented Generation)
+                include_chat_history: bool — Whether to include chat history in context
+                tags: list[str] — Tags to associate with the collection
+            workspace:
+                (Optional) The workspace id to be associated with this collection. None to use the default workspace.
         Returns:
             str: The ID of the newly created collection.
         """
@@ -1078,6 +1143,7 @@ class H2OGPTEAsync:
                     collection_settings
                 ),
                 chat_settings=rest.ChatSettings.from_dict(chat_settings),
+                workspace=workspace,
             )
             collection = await _rest_to_client_exceptions(
                 rest_client.collection_api.create_collection(request, _headers=headers)
@@ -1759,20 +1825,21 @@ class H2OGPTEAsync:
             llm_args:
                 Dictionary of kwargs to pass to the llm. Valid keys:
                     temperature (float, default: 0) — The value used to modulate the next token probabilities. Most deterministic: 0, Most creative: 1
-                    top_k (int, default: 1) — The number of highest probability vocabulary tokens to keep for top-k-filtering.
-                    top_p (float, default: 1.0) — If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation.
-                    seed (int, default: 0) — The seed for the random number generator when sampling during generation (if temp>0 or top_k>1 or top_p<1), seed=0 picks a random seed.
-                    repetition_penalty (float, default: 1.07) — The parameter for repetition penalty. 1.0 means no penalty.
-                    max_new_tokens (int, default: 1024) — Maximum number of new tokens to generate. This limit applies to each (map+reduce) step during summarization and each (map) step during extraction.
-                    min_max_new_tokens (int, default: 512) — minimum value for max_new_tokens when auto-adjusting for content of prompt, docs, etc.
-                    response_format (str, default: "text") — Output type, one of ["text", "json_object", "json_code"].
-                    guided_json (dict, default: None) — If specified, the output will follow the JSON schema.
-                    guided_regex (str, default: "") — If specified, the output will follow the regex pattern. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_choice (Optional[List[str]], default: None — If specified, the output will be exactly one of the choices. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_grammar (str, default: "") — If specified, the output will follow the context free grammar. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    guided_whitespace_pattern (str, default: "") — If specified, will override the default whitespace pattern for guided json decoding. Only for models that support guided generation: check output of get_llms() for guided_vllm flag.
-                    enable_vision (str, default: "auto") - Controls vision mode, send images to the LLM in addition to text chunks. Only if have models that support vision, use get_vision_capable_llm_names() to see list. One of ["on", "off", "auto"].
-                    visible_vision_models (List[str], default: ["auto"]) - Controls which vision model to use when processing images. Use get_vision_capable_llm_names() to see list. Must provide exactly one model. ["auto"] for automatic.
+                    top_k (int, default: 1) — The number of highest probability vocabulary tokens to keep for top-k-filtering
+                    top_p (float, default: 1.0) — If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation
+                    seed (int, default: 0) — The seed for the random number generator when sampling during generation (if temp>0 or top_k>1 or top_p<1), seed=0 picks a random seed
+                    repetition_penalty (float, default: 1.07) — The parameter for repetition penalty. 1.0 means no penalty
+                    max_new_tokens (int, default: 1024) — Maximum number of new tokens to generate. This limit applies to each (map+reduce) step during summarization and each (map) step during extraction
+                    reasoning_effort (int, default: 0) — Level of reasoning effort for the model (higher values = deeper reasoning, e.g., 10000-65000). Use for models that support chain-of-thought reasoning. 0 means no additional reasoning effort
+                    min_max_new_tokens (int, default: 512) — Minimum value for max_new_tokens when auto-adjusting for content of prompt, docs, etc.
+                    response_format (str, default: "text") — Output type, one of ["text", "json_object", "json_code"]
+                    guided_json (dict, default: None) — If specified, the output will follow the JSON schema
+                    guided_regex (str, default: "") — If specified, the output will follow the regex pattern. Only for models that support guided generation
+                    guided_choice (Optional[List[str]], default: None) — If specified, the output will be exactly one of the choices. Only for models that support guided generation
+                    guided_grammar (str, default: "") — If specified, the output will follow the context free grammar. Only for models that support guided generation
+                    guided_whitespace_pattern (str, default: "") — If specified, will override the default whitespace pattern for guided json decoding. Only for models that support guided generation
+                    enable_vision (str, default: "auto") — Controls vision mode, send images to the LLM in addition to text chunks. Only if have models that support vision, use get_vision_capable_llm_names() to see list. One of ["on", "off", "auto"]
+                    visible_vision_models (List[str], default: ["auto"]) — Controls which vision model to use when processing images. Use get_vision_capable_llm_names() to see list. Must provide exactly one model. ["auto"] for automatic
             max_num_chunks:
                 Max limit of chunks to send to the summarizer
             sampling_strategy:
@@ -2609,6 +2676,92 @@ class H2OGPTEAsync:
             )
         return await self._wait_for_completion(response.id, timeout=timeout)
 
+    async def ingest_from_confluence(
+        self,
+        collection_id: str,
+        base_url: str,
+        page_id: Union[str, List[str]],
+        credentials: ConfluenceCredential,
+        gen_doc_summaries: Union[bool, None] = None,
+        gen_doc_questions: Union[bool, None] = None,
+        audio_input_language: Union[str, None] = None,
+        ocr_model: Union[str, None] = None,
+        tesseract_lang: Union[str, None] = None,
+        keep_tables_as_one_chunk: Union[bool, None] = None,
+        chunk_by_page: Union[bool, None] = None,
+        handwriting_check: Union[bool, None] = None,
+        metadata: Union[Dict[str, Any], None] = None,
+        timeout: Union[float, None] = None,
+        ingest_mode: Union[str, None] = None,
+    ):
+        """Ingests confluence pages into collection.
+
+        Args:
+            collection_id:
+                String id of the collection to add the ingested documents into.
+            base_url:
+                Url of confluence instance. Example: https://h2oai.atlassian.net/wiki
+            page_id:
+                The page id or ids of pages to be ingested.
+            credentials:
+                The object with Confluence credentials.
+            gen_doc_summaries:
+                Whether to auto-generate document summaries (uses LLM)
+            gen_doc_questions:
+                Whether to auto-generate sample questions for each document (uses LLM)
+            audio_input_language:
+                Language of audio files. Defaults to "auto" language detection. Pass empty string to see choices.
+            ocr_model:
+                Which method to use to extract text from images using AI-enabled optical character recognition (OCR) models.
+                Pass empty string to see choices.
+                docTR is best for Latin text, PaddleOCR is best for certain non-Latin languages, Tesseract covers a wide range of languages.
+                Mississippi works well on handwriting.
+                "auto" - Automatic will auto-select the best OCR model for every page.
+                "off" - Disable OCR for speed, but all images will then be skipped (also no image captions will be made).
+            tesseract_lang:
+                Which language to use when using ocr_model="tesseract". Pass empty string to see choices.
+            keep_tables_as_one_chunk:
+                When tables are identified by the table parser the table tokens will be kept in a single chunk.
+            chunk_by_page:
+                Each page will be a chunk. `keep_tables_as_one_chunk` will be ignored if this is True.
+            handwriting_check:
+                Check pages for handwriting. Will use specialized models if handwriting is found.
+            metadata:
+                Dictionary of metadata to add to the document.
+            timeout:
+                Timeout in seconds.
+            ingest_mode:
+                Ingest mode to use.
+                "standard" - Files will be ingested for use with RAG
+                "lite" - Files will be ingested for use with RAG, but minimal processing will be done, favoring ingest speed over accuracy
+                "agent_only" - Bypasses standard ingestion. Files can only be used with agents.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            response = await _rest_to_client_exceptions(
+                rest_client.ingestion_api.create_ingest_from_confluence_job(
+                    collection_id=collection_id,
+                    ingest_from_confluence_body=rest.IngestFromConfluenceBody(
+                        base_url=base_url,
+                        page_ids=[page_id] if isinstance(page_id, str) else page_id,
+                        credentials=rest.ConfluenceCredentials(**credentials.__dict__),
+                        metadata=metadata,
+                    ),
+                    gen_doc_summaries=gen_doc_summaries,
+                    gen_doc_questions=gen_doc_questions,
+                    audio_input_language=audio_input_language,
+                    ocr_model=ocr_model,
+                    tesseract_lang=tesseract_lang,
+                    keep_tables_as_one_chunk=keep_tables_as_one_chunk,
+                    chunk_by_page=chunk_by_page,
+                    handwriting_check=handwriting_check,
+                    ingest_mode=ingest_mode,
+                    timeout=timeout,
+                    _headers=header,
+                )
+            )
+        return await self._wait_for_completion(response.id, timeout=timeout)
+
     async def list_secret_ids(self, connector_type: Optional[str] = None) -> List[str]:
         """
         List available secret IDs from the SecureStore for cloud storage connectors.
@@ -2727,6 +2880,7 @@ class H2OGPTEAsync:
         metadata: Union[Dict[str, Any], None] = None,
         timeout: Union[float, None] = None,
         ingest_mode: Union[str, None] = None,
+        callback: Optional[Callable[[Job], None]] = None,
     ) -> Job:
         """Add uploaded documents into a specific collection.
 
@@ -2773,6 +2927,8 @@ class H2OGPTEAsync:
                 "standard" - Files will be ingested for use with RAG
                 "lite" - Files will be ingested for use with RAG, but minimal processing will be done, favoring ingest speed over accuracy
                 "agent_only" - Bypasses standard ingestion. Files can only be used with agents.
+            callback:
+                Function for processing job status info during the upload.
         """
         header = await self._get_auth_header()
         async with self._RESTClient(self) as rest_client:
@@ -2800,7 +2956,9 @@ class H2OGPTEAsync:
                     _headers=header,
                 )
             )
-        return await self._wait_for_completion(response.id, timeout=timeout)
+        return await self._wait_for_completion(
+            response.id, timeout=timeout, callback=callback
+        )
 
     async def ingest_website(
         self,
@@ -3815,7 +3973,9 @@ class H2OGPTEAsync:
             )
         return result
 
-    async def make_collection_public(self, collection_id: str):
+    async def make_collection_public(
+        self, collection_id: str, permissions: Optional[List[str]] = None
+    ):
         """Make a collection public
 
         Once a collection is public, it will be accessible to all
@@ -3824,6 +3984,8 @@ class H2OGPTEAsync:
         Args:
             collection_id:
                 ID of the collection to make public.
+            permissions:
+                Optional: Collection specific permissions. If not provided, all permissions will default to true.
         """
         header = await self._get_auth_header()
         async with self._RESTClient(self) as rest_client:
@@ -3831,7 +3993,7 @@ class H2OGPTEAsync:
                 rest_client.collection_api.update_collection_privacy(
                     collection_id=collection_id,
                     update_collection_privacy_request=rest.UpdateCollectionPrivacyRequest(
-                        is_public=True
+                        is_public=True, permissions=permissions
                     ),
                     _headers=header,
                 )
@@ -3925,6 +4087,300 @@ class H2OGPTEAsync:
             )
         return result
 
+    async def list_extractor_permissions(
+        self, extractor_id: str
+    ) -> List[SharePermission]:
+        """Returns a list of access permissions for a given extractor.
+
+        The returned list of permissions denotes who has access to
+        the extractor and their access level.
+
+        Args:
+            extractor_id:
+                ID of the extractor to inspect.
+
+        Returns:
+            list of SharePermission: Sharing permissions list for the given extractor.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            response = await _rest_to_client_exceptions(
+                rest_client.extractor_api.get_extractor_permissions(
+                    extractor_id=extractor_id,
+                    _headers=header,
+                )
+            )
+        return [SharePermission(**d.to_dict()) for d in response]
+
+    async def list_extractor_group_permissions(
+        self, extractor_id: str
+    ) -> List[GroupSharePermission]:
+        """Returns a list of group access permissions for a given extractor.
+
+        The returned list of group permissions denoting which groups have access to
+        the extractor and their access level.
+
+        Args:
+            extractor_id:
+                ID of the extractor to inspect.
+
+        Returns:
+            list of GroupSharePermission: Group sharing permissions list for the given extractor.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            response = await _rest_to_client_exceptions(
+                rest_client.extractor_api.get_extractor_group_permissions(
+                    extractor_id=extractor_id,
+                    _headers=header,
+                )
+            )
+        return [GroupSharePermission(**d.to_dict()) for d in response]
+
+    async def share_extractor(
+        self, extractor_id: str, permission: SharePermission
+    ) -> ShareResponseStatus:
+        """Share an extractor to a user.
+
+        The permission attribute defined the level of access,
+        and who can access the extractor, the extractor_id attribute
+        denotes the extractor to be shared.
+
+        Args:
+            extractor_id:
+                ID of the extractor to share.
+            permission:
+                Defines the rule for sharing, i.e. permission level.
+
+        Returns:
+            ShareResponseStatus: Status of share request.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = await _get_share_permission_status(
+                _rest_to_client_exceptions(
+                    rest_client.extractor_api.share_extractor(
+                        extractor_id=extractor_id,
+                        username=permission.username,
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
+    async def unshare_extractor(
+        self, extractor_id: str, permission: SharePermission
+    ) -> ShareResponseStatus:
+        """Remove sharing of an extractor to a user.
+
+        The permission attribute defined the level of access,
+        and who can access the extractor, the extractor_id attribute
+        denotes the extractor to be shared.
+
+        In case of un-sharing, the SharePermission's user is sufficient.
+
+        Args:
+            extractor_id:
+                ID of the extractor to un-share.
+            permission:
+                Defines the user for which extractor access is revoked.
+
+        ShareResponseStatus: Status of share request.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = await _get_share_permission_status(
+                _rest_to_client_exceptions(
+                    rest_client.extractor_api.unshare_extractor(
+                        extractor_id=extractor_id,
+                        username=permission.username,
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
+    async def reset_and_share_extractor(
+        self, extractor_id: str, new_usernames: List[str]
+    ) -> ShareResponseStatus:
+        """Remove all users who have access to an extractor (except for the owner) and share it with the provided list of new users.
+
+        Args:
+            extractor_id:
+                ID of the extractor to un-share.
+            new_usernames:
+                The list of usernames belonging to the users this extractor will be shared with.
+
+        ShareResponseStatus: Status of share request.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = await _get_share_permission_status(
+                _rest_to_client_exceptions(
+                    rest_client.extractor_api.reset_and_share_extractor(
+                        extractor_id=extractor_id,
+                        reset_and_share_request=rest.ResetAndShareRequest(
+                            usernames=new_usernames,
+                        ),
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
+    async def unshare_extractor_for_all(self, extractor_id: str) -> ShareResponseStatus:
+        """Remove sharing of an extractor to all other users but the original owner.
+
+        Args:
+            extractor_id:
+                ID of the extractor to un-share.
+
+        ShareResponseStatus: Status of share request.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = await _get_share_permission_status(
+                _rest_to_client_exceptions(
+                    rest_client.extractor_api.unshare_extractor_for_all(
+                        extractor_id=extractor_id,
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
+    async def share_extractor_with_group(
+        self, extractor_id: str, permission: GroupSharePermission
+    ) -> ShareResponseStatus:
+        """Share an extractor to a group.
+
+        The permission attribute defines which group can access the extractor,
+        the extractor_id attribute denotes the extractor to be shared.
+
+        Args:
+            extractor_id:
+                ID of the extractor to share.
+            permission:
+                Defines the group for sharing with.
+
+        Returns:
+            ShareResponseStatus: Status of share request.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = await _get_share_permission_status(
+                _rest_to_client_exceptions(
+                    rest_client.extractor_api.share_extractor_with_group(
+                        extractor_id=extractor_id,
+                        group_id=permission.group_id,
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
+    async def unshare_extractor_from_group(
+        self, extractor_id: str, permission: GroupSharePermission
+    ) -> ShareResponseStatus:
+        """Remove sharing of an extractor from a group.
+
+        The permission attribute defines which group to remove access from,
+        the extractor_id attribute denotes the extractor to be unshared.
+
+
+        Args:
+            extractor_id:
+                ID of the extractor to un-share.
+            permission:
+                Defines the group for which extractor access is revoked.
+
+        Returns:
+            ShareResponseStatus: Status of share request.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = await _get_share_permission_status(
+                _rest_to_client_exceptions(
+                    rest_client.extractor_api.unshare_extractor_from_group(
+                        extractor_id=extractor_id,
+                        group_id=permission.group_id,
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
+    async def reset_and_share_extractor_with_groups(
+        self, extractor_id: str, new_groups: List[str]
+    ) -> ShareResponseStatus:
+        """Remove all groups who have access to an extractor and share it with the provided list of new group ids.
+
+        Args:
+            extractor_id:
+                ID of the extractor to un-share.
+            new_groups:
+                The list of group ids this extractor will be shared with.
+
+        ShareResponseStatus: Status of share request.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = await _get_share_permission_status(
+                _rest_to_client_exceptions(
+                    rest_client.extractor_api.reset_and_share_extractor_with_groups(
+                        extractor_id=extractor_id,
+                        reset_and_share_with_groups_request=rest.ResetAndShareWithGroupsRequest(
+                            groups=new_groups,
+                        ),
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
+    async def make_extractor_public(self, extractor_id: str):
+        """Make an extractor public
+
+        Once an extractor is public, it can be seen and used by all users.
+
+        Args:
+            extractor_id:
+                ID of the extractor to make public.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            await _rest_to_client_exceptions(
+                rest_client.extractor_api.update_extractor_privacy(
+                    extractor_id=extractor_id,
+                    update_extractor_privacy_request=rest.UpdateExtractorPrivacyRequest(
+                        is_public=True
+                    ),
+                    _headers=header,
+                )
+            )
+
+    async def make_extractor_private(self, extractor_id: str):
+        """Make an extractor private
+
+        Once a extractor is private, other users will no longer
+        be able to see or use it unless it has been shared individually or by group.
+
+        Args:
+            extractore_id:
+                ID of the extractor to make private.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            await _rest_to_client_exceptions(
+                rest_client.extractor_api.update_extractor_privacy(
+                    extractor_id=extractor_id,
+                    update_extractor_privacy_request=rest.UpdateExtractorPrivacyRequest(
+                        is_public=False
+                    ),
+                    _headers=header,
+                )
+            )
+
     async def list_recent_documents(
         self, offset: int, limit: int, metadata_filter: dict = {}
     ) -> List[DocumentInfo]:
@@ -4353,6 +4809,31 @@ class H2OGPTEAsync:
             )
         return collection_id
 
+    async def update_collection_workspace(
+        self, collection_id: str, workspace: str
+    ) -> str:
+        """Update the workspace associated with a collection.
+
+        Args:
+            collection_id:
+                ID of the collection to update.
+            workspace:
+                The workspace associated with the collection.
+        """
+
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            await _rest_to_client_exceptions(
+                rest_client.collection_api.update_collection_workspace(
+                    collection_id=collection_id,
+                    update_collection_workspace_request=rest.UpdateCollectionWorkspaceRequest(
+                        workspace=workspace
+                    ),
+                    _headers=header,
+                )
+            )
+        return collection_id
+
     async def update_document_name(self, document_id: str, name: str) -> str:
         """Update the name metadata for a given document.
 
@@ -5251,7 +5732,7 @@ class H2OGPTEAsync:
                 _rest_to_client_exceptions(
                     rest_client.prompt_template_api.reset_and_share_prompt_template_with_groups(
                         prompt_template_id=prompt_id,
-                        reset_and_share_prompt_template_with_groups_request=rest.ResetAndSharePromptTemplateWithGroupsRequest(
+                        reset_and_share_with_groups_request=rest.ResetAndShareWithGroupsRequest(
                             groups=new_groups,
                         ),
                         _headers=header,
@@ -5299,7 +5780,7 @@ class H2OGPTEAsync:
                 _rest_to_client_exceptions(
                     rest_client.prompt_template_api.reset_and_share_prompt_template(
                         prompt_template_id=prompt_id,
-                        reset_and_share_prompt_template_request=rest.ResetAndSharePromptTemplateRequest(
+                        reset_and_share_request=rest.ResetAndShareRequest(
                             usernames=new_usernames,
                         ),
                         _headers=header,
@@ -5574,6 +6055,27 @@ class H2OGPTEAsync:
 
         return await self.get_prompt_template(rest_session.prompt_template_id)
 
+    async def get_chat_session_workspace(self, chat_session_id: str) -> str:
+        """Get the workspace associated with the chat session.
+
+        Args:
+            chat_session_id:
+                String id of the chat session to search for.
+
+        Returns:
+            str: The identifier of the workspace
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            response = await _rest_to_client_exceptions(
+                rest_client.chat_api.get_chat_session(
+                    session_id=chat_session_id,
+                    _headers=header,
+                )
+            )
+
+        return response.workspace
+
     async def set_chat_session_collection(
         self, chat_session_id: str, collection_id: Union[str, None]
     ) -> str:
@@ -6682,6 +7184,37 @@ class H2OGPTEAsync:
             )
 
     async def add_agent_key(self, agent_keys: List[dict]) -> List[dict]:
+        """Create one or more agent keys for use with agent tools.
+
+        Processes a list of agent key configurations and creates each key.
+        Continues processing remaining keys if individual key creation fails.
+
+        Args:
+            agent_keys: List of key configuration dictionaries.
+
+                Expected structure::
+
+                    [
+                        {
+                            "name": str,
+                                # Display name for the key
+
+                            "value": str,
+                                # The actual key/token value
+
+                            "key_type": str,
+                                # Type of key ("private" or "shared")
+
+                            "description": str,
+                                # (Optional) Description of the key's purpose
+                        }
+                    ]
+
+        Returns:
+            List[dict]: List of created key results. Each successful creation
+                returns {"agent_key_id": str}. Failed creations are logged but
+                don't appear in results.
+        """
         result = []
         header = await self._get_auth_header()
         async with self._RESTClient(self) as rest_client:
@@ -6748,6 +7281,29 @@ class H2OGPTEAsync:
     async def assign_agent_key_for_tool(
         self, tool_dict_list: List[dict]
     ) -> Optional[List[Tuple]]:
+        """Assign agent keys to tools by creating associations between them.
+
+        Args:
+            tool_dict_list: List of dictionaries containing tool association data.
+                Each dictionary should have a "tool_dict" key with the association
+                configuration data for creating agent tool key associations.
+
+                Expected tool_dict structure::
+
+                    {
+                        "tool": str,        # Name of the tool (for example, "test_tool").
+                        "keys": list[dict], # List of key definitions. Each item is a dictionary with:
+                                           #   - "name": str
+                                           #       Environment variable name (for example, "TEST_KEY").
+                                           #   - "key_id": Any
+                                           #       Identifier assigned to the key (for example, agent_key_id).
+                    }
+
+        Returns:
+            Optional[List[Tuple]]: List of tuples containing association details.
+                Each tuple contains (associate_id, tool, key_name, key_id, user_id).
+                Returns None if no associations were created.
+        """
         result = []
         header = await self._get_auth_header()
         async with self._RESTClient(self) as rest_client:
@@ -6976,7 +7532,10 @@ class H2OGPTEAsync:
         return await self._post("/rpc/sharing", args)
 
     async def _wait_for_completion(
-        self, job_id: str, timeout: Optional[float] = None
+        self,
+        job_id: str,
+        timeout: Optional[float] = None,
+        callback: Optional[Callable[[Job], None]] = None,
     ) -> Job:
         if timeout is None:
             timeout = 86400
@@ -6984,6 +7543,8 @@ class H2OGPTEAsync:
         last_job: Optional[Job] = None
         while True:
             job = await self.get_job(job_id)
+            if callback:
+                callback(job)
             if job.completed or job.canceled:
                 # will reach here if processing times out (self cancels since quit is set to 1)
                 break