h2ogpte 1.6.41rc5__py3-none-any.whl → 1.6.43rc1__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
@@ -170,6 +170,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 +297,65 @@ 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_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 +467,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 +578,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 +898,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 +918,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 +937,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 +1025,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 +1072,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 +1105,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 +1119,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 +1140,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 +1822,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:
@@ -2727,6 +2791,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 +2838,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 +2867,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,
@@ -3925,6 +3994,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 +4716,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 +5639,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 +5687,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 +5962,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:
@@ -6976,7 +7385,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 +7396,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