kash-shell 0.3.34__py3-none-any.whl → 0.3.36__py3-none-any.whl

kash/config/env_settings.py

@@ -22,9 +22,6 @@ class KashEnv(EnvEnum):
     KASH_SYSTEM_CACHE_DIR = "KASH_SYSTEM_CACHE_DIR"
     """The directory for system cache (caches separate from workspace caches)."""
 
-    KASH_MCP_WS = "KASH_MCP_WS"
-    """The directory for the workspace for MCP servers."""
-
     KASH_SHOW_TRACEBACK = "KASH_SHOW_TRACEBACK"
     """Whether to show tracebacks on actions and commands in the shell."""
 

kash/config/logger.py

@@ -281,6 +281,8 @@ def _do_logging_setup(log_settings: LogSettings):
 def prefix(line: str, emoji: str = "", warn_emoji: str = "") -> str:
     prefix = task_stack_prefix_str()
     emojis = f"{warn_emoji}{emoji}".strip()
+    if emojis:
+        emojis += " "
     return "".join(filter(None, [prefix, emojis, line]))
 
 

kash/config/logger_basic.py

@@ -19,7 +19,16 @@ class SuppressedWarningsStreamHandler(logging.StreamHandler):
 def basic_file_handler(path: Path, level: LogLevel | LogLevelStr) -> logging.FileHandler:
     handler = logging.FileHandler(path)
     handler.setLevel(LogLevel.parse(level).value)
-    handler.setFormatter(Formatter("%(asctime)s %(levelname).1s %(name)s - %(message)s"))
+
+    class ThreadIdFormatter(Formatter):
+        def format(self, record):
+            # Add shortened thread ID as an attribute
+            record.thread_short = str(record.thread)[-5:]
+            return super().format(record)
+
+    handler.setFormatter(
+        ThreadIdFormatter("%(asctime)s %(levelname).1s [T%(thread_short)s] %(name)s - %(message)s")
+    )
     return handler
 
 

kash/config/settings.py

@@ -166,9 +166,6 @@ class Settings:
     system_cache_dir: Path
     """Default global and system cache directory (for global media, content, etc)."""
 
-    mcp_ws_dir: Path | None
-    """The directory for the MCP workspace, if set."""
-
     local_server_log_path: Path
     """The path to the local server log."""
 
@@ -245,14 +242,6 @@ def _get_system_cache_dir() -> Path:
     return KashEnv.KASH_SYSTEM_CACHE_DIR.read_path(default=_get_ws_root_dir() / "cache")
 
 
-def _get_mcp_ws_dir() -> Path | None:
-    mcp_dir = KashEnv.KASH_MCP_WS.read_str(default=None)
-    if mcp_dir:
-        return Path(mcp_dir).expanduser().resolve()
-    else:
-        return None
-
-
 @cache
 def _get_local_server_log_path() -> Path:
     return resolve_and_create_dirs(get_system_logs_dir() / f"{LOCAL_SERVER_LOG_NAME}.log")
@@ -266,7 +255,6 @@ def _read_settings():
         system_config_dir=_get_system_config_dir(),
         system_logs_dir=get_system_logs_dir(),
         system_cache_dir=_get_system_cache_dir(),
-        mcp_ws_dir=_get_mcp_ws_dir(),
         local_server_log_path=_get_local_server_log_path(),
         # These default to the global but can be overridden by workspace settings.
         media_cache_dir=_get_system_cache_dir() / MEDIA_CACHE_NAME,

kash/config/setup.py

@@ -75,6 +75,21 @@ def kash_setup(
 
 
 def _lib_setup():
+    import logging
+
+    log = logging.getLogger(__name__)
+
+    # Trust store integration, for consistent TLS behavior.
+    try:
+        import truststore  # type: ignore
+
+        truststore.inject_into_ssl()
+        log.info("truststore initialized: using system TLS trust store")
+    except Exception as exc:
+        # If not installed or fails, default TLS trust will be used.
+        log.warning("truststore not available at import time: %s", exc)
+
+    # Handle default YAML representers.
     from sidematter_format import register_default_yaml_representers
 
     register_default_yaml_representers()

kash/config/text_styles.py

@@ -262,7 +262,7 @@ PROMPT_ASSIST = "(assistant) ❯"
 
 EMOJI_HINT = "👉"
 
-EMOJI_MSG_INDENT = "⋮   "
+EMOJI_MSG_INDENT = "⋮ "
 
 EMOJI_START = "[➤]"
 

kash/config/warm_slow_imports.py

@@ -0,0 +1,60 @@
+from funlog import log_calls
+
+from kash.config.logger import get_logger
+from kash.utils.common.import_utils import warm_import_library
+
+log = get_logger(__name__)
+
+
+@log_calls(level="info", show_timing_only=True)
+def warm_slow_imports(include_extras: bool = True):
+    """
+    Pre-import slow packages to avoid delays when they are first used.
+
+    Args:
+        include_extras: If True, warm import optional libraries like LLM packages,
+                        scipy, torch, etc. Set to False for minimal/faster startup.
+    """
+    try:
+        # Loading actions also loads any kits that are discovered.
+        import kash.actions  # noqa: F401
+        import kash.local_server  # noqa: F401
+        import kash.local_server.local_server  # noqa: F401
+        import kash.mcp.mcp_server_sse  # noqa: F401
+
+        # Core libraries that should usually be present
+        for lib_name, max_depth in [("xonsh", 3), ("uvicorn", 3)]:
+            try:
+                warm_import_library(lib_name, max_depth=max_depth)
+            except Exception as e:
+                log.debug(f"Could not warm import {lib_name}: {e}")
+
+        if include_extras:
+            # Fully warm import larger libraries (only if they're installed)
+            # These are optional dependencies that may not be present
+            optional_libraries = [
+                ("pydantic", 5),
+                ("litellm", 5),
+                ("openai", 5),
+                ("torch", 3),  # torch is huge, limit depth
+                ("scipy", 3),  # scipy has test modules we want to skip
+                ("marker", 4),
+                ("pandas", 3),
+            ]
+
+            for lib_name, max_depth in optional_libraries:
+                try:
+                    warm_import_library(lib_name, max_depth=max_depth)
+                except Exception as e:
+                    log.debug(f"Could not warm import {lib_name}: {e}")
+
+            # Initialize litellm configuration if available
+            try:
+                from kash.llm_utils.init_litellm import init_litellm
+
+                init_litellm()
+            except ImportError:
+                pass  # litellm not installed
+
+    except ImportError as e:
+        log.warning(f"Error pre-importing packages: {e}")

kash/exec/action_decorators.py

@@ -204,7 +204,7 @@ def kash_action(
     precondition: Precondition = Precondition.always,
     arg_type: ArgType = ArgType.Locator,
     expected_args: ArgCount = ONE_ARG,
-    output_type: ItemType = ItemType.doc,
+    output_type: ItemType | None = None,
     output_format: Format | None = None,
     expected_outputs: ArgCount = ONE_ARG,
     params: ParamDeclarations = (),
@@ -349,7 +349,7 @@ def kash_action(
                         fmt_lines(self.params),
                     )
                     log.info(
-                        "Action function param values:\n%s",
+                        "Action function param values: %s",
                         self.param_value_summary_str(),
                     )
                 else:

kash/exec/action_exec.py

@@ -107,7 +107,7 @@ def log_action(action: Action, action_input: ActionInput, operation: Operation):
     log.message("%s Action: `%s`", EMOJI_START, action.name)
     log.info("Running: `%s`", operation.command_line(with_options=True))
     if len(action.param_value_summary()) > 0:
-        log.message("Parameters:\n%s", action.param_value_summary_str())
+        log.message("Parameters: %s", action.param_value_summary_str())
     log.info("Operation is: %s", operation)
     log.info("Input items are:\n%s", fmt_lines(action_input.items))
 

kash/exec/fetch_url_items.py

@@ -144,15 +144,17 @@ def fetch_url_item_content(
         if save_content:
             assert page_data.saved_content
             assert page_data.format_info
+            if not page_data.format_info.format:
+                log.warning("No format detected for content, defaulting to HTML: %s", url)
             content_item = url_item.new_copy_with(
                 external_path=str(page_data.saved_content),
                 # Use the original filename, not the local cache filename (which has a hash suffix).
                 original_filename=item.get_filename(),
-                format=page_data.format_info.format,
+                format=page_data.format_info.format or Format.html,
             )
 
     if not url_item.title:
-        log.warning("Failed to fetch page data: title is missing: %s", item.url)
+        log.info("Title is missing for url item: %s", item)
 
     # Now save the updated URL item and also the content item if we have one.
     ws.save(url_item, overwrite=overwrite)

kash/exec/llm_transforms.py

@@ -29,6 +29,7 @@ def windowed_llm_transform(
     windowing: WindowSettings | None,
     diff_filter: DiffFilter | None = None,
     check_no_results: bool = True,
+    enable_web_search: bool = False,
 ) -> TextDoc:
     def doc_transform(input_doc: TextDoc) -> TextDoc:
         return TextDoc.from_text(
@@ -41,6 +42,7 @@ def windowed_llm_transform(
                     input=input_doc.reassemble(),
                     body_template=template,
                     check_no_results=check_no_results,
+                    enable_web_search=enable_web_search,
                 ).content
             )
         )
@@ -67,6 +69,7 @@ def llm_transform_str(options: LLMOptions, input_str: str, check_no_results: boo
             input_str,
             options.windowing,
             diff_filter=options.diff_filter,
+            enable_web_search=options.enable_web_search,
         ).reassemble()
     else:
         log.info(
@@ -81,6 +84,7 @@ def llm_transform_str(options: LLMOptions, input_str: str, check_no_results: boo
             body_template=options.body_template,
             input=input_str,
             check_no_results=check_no_results,
+            enable_web_search=options.enable_web_search,
         ).content
 
     return result_str

kash/file_storage/file_store.py

@@ -485,6 +485,9 @@ class FileStore(Workspace):
         If `with_sidematter` is true, will copy any sidematter files (metadata/assets) to
         the destination.
         """
+        # TODO: Make sure importing a text item that already has
+        # frontmatter doesn't accidentally duplicate the frontmatter
+
         from kash.file_storage.item_file_format import read_item
         from kash.web_content.canon_url import canonicalize_url
 
@@ -531,6 +534,7 @@ class FileStore(Workspace):
                 # This will read the file with or without frontmatter.
                 # We are importing so we want to drop the external path so we save the body.
                 item = read_item(path, self.base_dir)
+                log.info("Imported text item: %s", item)
                 item.external_path = None
 
                 if item.type and as_type and item.type != as_type:

kash/llm_utils/llm_completion.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import time
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from flowmark import Wrap, fill_text
 from funlog import format_duration, log_calls
@@ -51,6 +51,7 @@ class LLMCompletionResult:
     message: LiteLLMMessage
     content: str
     citations: CitationList | None
+    tool_calls: list[dict[str, Any]] | None = None
 
     @property
     def content_with_citations(self) -> str:
@@ -59,40 +60,111 @@ class LLMCompletionResult:
             content = content + "\n\n" + self.citations.as_markdown_footnotes()
         return content
 
+    @property
+    def has_tool_calls(self) -> bool:
+        """Check if the response contains tool calls."""
+        return bool(self.tool_calls)
+
+    @property
+    def tool_call_names(self) -> list[str]:
+        """Get list of tool names that were called."""
+        if not self.tool_calls:
+            return []
+        names = []
+        for call in self.tool_calls:
+            # Handle both LiteLLM objects and dict representations
+            if hasattr(call, "function") and hasattr(getattr(call, "function", None), "name"):
+                # LiteLLM object format
+                names.append(f"{call.function.name}()")  # pyright: ignore[reportAttributeAccessIssue]
+            elif isinstance(call, dict) and call.get("function", {}).get("name"):
+                # Dict format
+                names.append(f"{call['function']['name']}()")
+            else:
+                names.append(str(call))
+        return names
+
 
 @log_calls(level="info")
 def llm_completion(
     model: LLMName,
     messages: list[dict[str, str]],
     save_objects: bool = True,
-    response_format: dict | type[BaseModel] | None = None,
+    response_format: dict[str, Any] | type[BaseModel] | None = None,
+    tools: list[dict[str, Any]] | None = None,
+    enable_web_search: bool = False,
     **kwargs,
 ) -> LLMCompletionResult:
     """
     Perform an LLM completion with LiteLLM.
+
+    Args:
+        model: The LLM model to use
+        messages: Chat messages
+        save_objects: Whether to save chat history
+        response_format: Response format specification
+        tools: List of tools available for function calling (e.g., web_search)
+        enable_web_search: If True, automatically add web search tools for the model
+        **kwargs: Additional LiteLLM parameters
     """
-    import litellm
     from litellm.types.utils import Choices, ModelResponse
 
     init_litellm()
 
+    # Prepare completion parameters
+    completion_params = {
+        "model": model.litellm_name,
+        "messages": messages,
+        **kwargs,
+    }
+
+    # Auto-enable web search if requested
+    if enable_web_search:
+        import litellm
+
+        if litellm.supports_web_search(model=model.litellm_name):
+            log.message("Enabling web search for model %s", model.litellm_name)
+            completion_params["web_search_options"] = {"search_context_size": "medium"}
+        else:
+            log.warning("Web search requested but not supported by model %s", model.litellm_name)
+
     chat_history = ChatHistory.from_dicts(messages)
+
+    # Enhanced logging to detect tool use
+    tools_info = f", {len(tools)} tools" if tools else ", no tools"
     log.info(
-        "Calling LLM completion from %s on %s, response_format=%s",
+        "Calling LLM completion from %s on %s, response_format=%s%s",
         model.litellm_name,
         chat_history.size_summary(),
         response_format,
+        tools_info,
     )
 
+    if tools:
+        tool_names = []
+        for tool in tools:
+            if tool.get("type") == "function":
+                tool_names.append(tool.get("function", {}).get("name", "unknown"))
+            elif tool.get("type") == "native_web_search":
+                tool_names.append("native_web_search")
+            else:
+                tool_names.append(tool.get("type", "unknown"))
+
+        log.message("Tools enabled: %s", tool_names)
+
     start_time = time.time()
+
+    if response_format:
+        completion_params["response_format"] = response_format
+
+    if tools:
+        completion_params["tools"] = tools
+        log.info("Enabling function calling with %d tools", len(tools))
+
+    import litellm
+
     llm_output = cast(
         ModelResponse,
-        litellm.completion(
-            model.litellm_name,
-            messages=messages,
-            response_format=response_format,
-            **kwargs,
-        ),  # pyright: ignore
+        litellm.completion(**completion_params),  # pyright: ignore
     )
     elapsed = time.time() - start_time
 
@@ -100,23 +172,47 @@ def llm_completion(
 
     message = choices.message
 
+    # Extract tool calls from the response
+    tool_calls = getattr(message, "tool_calls", None)
+    tool_calls_list = list(tool_calls) if tool_calls else None
+
     # Just sanity checking and logging.
     content = choices.message.content
     if not content or not isinstance(content, str):
         raise ApiResultError(f"LLM completion failed: {model.litellm_name}: {llm_output}")
 
+    # Create the result object with tool calls
+    citations = llm_output.get("citations", None)
+    result = LLMCompletionResult(
+        message=message,
+        content=content,
+        citations=CitationList(citations=citations) if citations else None,
+        tool_calls=tool_calls_list,
+    )
+
+    # Log tool calls if present
+    if result.has_tool_calls:
+        tool_count = len(result.tool_calls or [])
+        log.message("LLM executed %d function calls: %s", tool_count, result.tool_call_names)
+        log.message(
+            "⚠️  Function calls require implementation - LLM requested tools but no handlers are implemented"
+        )
+
+    # Performance logging
     total_input_len = sum(len(m["content"]) for m in messages)
     speed = len(content) / elapsed
+    tool_count = len(result.tool_calls or []) if result.has_tool_calls else 0
+    tool_info = f", {tool_count} tool calls" if result.has_tool_calls else ""
     log.info(
         f"{EMOJI_TIMING} LLM completion from {model.litellm_name} in {format_duration(elapsed)}: "
         f"input {total_input_len} chars in {len(messages)} messages, output {len(content)} chars "
-        f"({speed:.0f} char/s)"
+        f"({speed:.0f} char/s){tool_info}"
     )
 
-    citations = llm_output.get("citations", None)
-
     if save_objects:
         metadata = {"citations": citations} if citations else {}
+        if result.has_tool_calls:
+            metadata["tool_calls"] = len(result.tool_calls or [])
         chat_history.messages.append(
             ChatMessage(role=ChatRole.assistant, content=content, metadata=metadata)
         )
@@ -128,11 +224,7 @@ def llm_completion(
             file_ext="yml",
         )
 
-    return LLMCompletionResult(
-        message=message,
-        content=content,
-        citations=CitationList(citations=citations) if citations else None,
-    )
+    return result
 
 
 def llm_template_completion(
@@ -143,7 +235,9 @@ def llm_template_completion(
     previous_messages: list[dict[str, str]] | None = None,
     save_objects: bool = True,
     check_no_results: bool = True,
-    response_format: dict | type[BaseModel] | None = None,
+    response_format: dict[str, Any] | type[BaseModel] | None = None,
+    tools: list[dict[str, Any]] | None = None,
+    enable_web_search: bool = False,
     **kwargs,
 ) -> LLMCompletionResult:
     """
@@ -169,6 +263,8 @@ def llm_template_completion(
         ],
         save_objects=save_objects,
         response_format=response_format,
+        tools=tools,
+        enable_web_search=enable_web_search,
         **kwargs,
     )
 

kash/llm_utils/llms.py

@@ -28,22 +28,23 @@ class LLM(LLMName, Enum):
     gpt_4_1 = LLMName("gpt-4.1")
     gpt_4o = LLMName("gpt-4o")
     gpt_4o_mini = LLMName("gpt-4o-mini")
+    gpt_4o_search_preview = LLMName("gpt-4o-search-preview")
     gpt_4 = LLMName("gpt-4")
     gpt_4_1_mini = LLMName("gpt-4.1-mini")
     gpt_4_1_nano = LLMName("gpt-4.1-nano")
 
-    # https://docs.anthropic.com/en/docs/about-claude/models/all-models
+    # https://docs.claude.com/en/docs/about-claude/models
 
-    claude_4_1_opus = LLMName("claude-opus-4-1")
-    claude_4_opus = LLMName("claude-opus-4-20250514")
-    claude_4_sonnet = LLMName("claude-sonnet-4-20250514")
-    claude_3_7_sonnet = LLMName("claude-3-7-sonnet-latest")
-    claude_3_5_haiku = LLMName("claude-3-5-haiku-latest")
+    claude_sonnet_4_5 = LLMName("claude-sonnet-4-5-20250929")
+    claude_haiku_4_5 = LLMName("claude-haiku-4-5-20251001")
+    claude_opus_4_1 = LLMName("claude-opus-4-1-20250805")
+    claude_sonnet_4 = LLMName("claude-sonnet-4-20250514")
+    claude_opus_4 = LLMName("claude-opus-4-20250514")
 
     # https://ai.google.dev/gemini-api/docs/models
     gemini_2_5_pro = LLMName("gemini/gemini-2.5-pro")
     gemini_2_5_flash = LLMName("gemini/gemini-2.5-flash")
-    gemini_2_5_flash_lite = LLMName("gemini-2.5-flash-lite-preview-06-17")
+    gemini_2_5_flash_lite = LLMName("gemini/gemini-2.5-flash-lite")
 
     # https://docs.x.ai/docs/models
     xai_grok_3 = LLMName("xai/grok-3")

kash/mcp/mcp_cli.py

@@ -11,8 +11,14 @@ from pathlib import Path
 
 from clideps.utils.readable_argparse import ReadableColorFormatter
 
-from kash.config.settings import DEFAULT_MCP_SERVER_PORT, LogLevel, global_settings
+from kash.config.settings import (
+    DEFAULT_MCP_SERVER_PORT,
+    LogLevel,
+    atomic_global_settings,
+    global_settings,
+)
 from kash.config.setup import kash_setup
+from kash.config.warm_slow_imports import warm_slow_imports
 from kash.shell.version import get_version
 
 __version__ = get_version()
@@ -26,8 +32,6 @@ log = logging.getLogger()
 
 
 def build_parser():
-    from kash.workspaces.workspaces import global_ws_dir
-
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=ReadableColorFormatter)
     parser.add_argument(
         "--version",
@@ -36,8 +40,8 @@ def build_parser():
     )
     parser.add_argument(
         "--workspace",
-        default=global_ws_dir(),
-        help=f"Set workspace directory. Defaults to kash global workspace directory: {global_ws_dir()}",
+        default=global_settings().global_ws_dir,
+        help=f"Set workspace directory. Defaults to kash global workspace directory: {global_settings().global_ws_dir}",
     )
     parser.add_argument(
         "--proxy",
@@ -95,6 +99,14 @@ def run_server(args: argparse.Namespace):
     log.warning("kash MCP CLI started, logging to: %s", MCP_CLI_LOG_PATH)
     log.warning("Current working directory: %s", Path(".").resolve())
 
+    # Eagerly import so the server is warmed up.
+    # This is important to save init time on fresh sandboxes like E2B!
+    warm_slow_imports(include_extras=True)
+
+    if args.workspace and args.workspace != global_settings().global_ws_dir:
+        with atomic_global_settings().updates() as settings:
+            settings.global_ws_dir = Path(args.workspace).absolute()
+
     ws: Workspace = get_ws(name_or_path=Path(args.workspace), auto_init=True)
     os.chdir(ws.base_dir)
     log.warning("Running in workspace: %s", ws.base_dir)

kash/mcp/mcp_server_routes.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 import asyncio
 import pprint
 from dataclasses import dataclass
+from pathlib import Path
 
+from clideps.env_vars.dotenv_utils import load_dotenv_paths
 from funlog import log_calls
 from mcp.server.lowlevel import Server
 from mcp.server.lowlevel.server import StructuredContent, UnstructuredContent
@@ -237,10 +239,10 @@ def run_mcp_tool(
     """
     try:
         with captured_output() as capture:
-            # XXX For now, unless the user has overridden the MCP workspace, we use the
-            # current workspace, which could be changed by the user by changing working
-            # directories. Maybe confusing?
-            explicit_mcp_ws = global_settings().mcp_ws_dir
+            dotenv_paths = load_dotenv_paths(True, True, Path("."))
+            log.warning("Loaded .env files: %s", dotenv_paths)
+            # Use the global workspace default
+            explicit_mcp_ws = global_settings().global_ws_dir
 
             with kash_runtime(
                 workspace_dir=explicit_mcp_ws,

kash/model/actions_model.py

@@ -171,6 +171,7 @@ class LLMOptions:
     body_template: MessageTemplate = MessageTemplate("{body}")
     windowing: WindowSettings = WINDOW_NONE
     diff_filter: DiffFilter | None = None
+    enable_web_search: bool = False
 
     def updated_with(self, param_name: str, value: Any) -> LLMOptions:
         """Update option from an action parameter."""
@@ -244,11 +245,12 @@ class Action(ABC):
     be ONE_ARG.
     """
 
-    output_type: ItemType = ItemType.doc
+    output_type: ItemType | None = None
     """
     The type of the output item(s). If an action returns multiple output types,
     this will be the output type of the first output.
     This is mainly used for preassembly for the cache check if an output already exists.
+    None means to use the input type.
     """
 
     output_format: Format | None = None
@@ -451,7 +453,7 @@ class Action(ABC):
         return changed_params
 
     def param_value_summary_str(self) -> str:
-        return fmt_lines(
+        return ", ".join(
             [format_key_value(name, value) for name, value in self.param_value_summary().items()]
         )
 
@@ -542,8 +544,8 @@ class Action(ABC):
     def preassemble_result(self, context: ActionContext) -> ActionResult | None:
         """
         Actions can have a separate preliminary step to pre-assemble outputs. This allows
-        us to determine the title and types for the output items and check if they were
-        already generated before running slow or expensive actions.
+        us to determine thew expected shape of the expected output and check if it already
+        exists.
 
         For now, this only applies to actions with a single output, when `self.cacheable`
         is True.
@@ -560,7 +562,17 @@ class Action(ABC):
             # Using first input to determine the output title.
             primary_input = context.action_input.items[0]
             # In this case we only expect one output, of the type specified by the action.
-            primary_output = primary_input.derived_copy(context, 0, type=context.action.output_type)
+            output_type = context.action.output_type or primary_input.type
+            if not output_type:
+                log.warning(
+                    "No output type specified for action `%s`, using `doc` for preassembly",
+                    self.name,
+                )
+                output_type = ItemType.doc
+            output_format = context.action.output_format or primary_input.format
+            primary_output = primary_input.derived_copy(
+                context, 0, type=output_type, format=output_format
+            )
             log.info("Preassembled output: source %s, %s", primary_output.source, primary_output)
             return ActionResult([primary_output])
         else: