Publish LumynaX Infused Gemma E4B Model

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+merged_model/tokenizer.json filter=lfs diff=lfs merge=lfs -text

LICENSE.txt

@@ -0,0 +1,11 @@
+LumynaX Infused Gemma E4B Model
+Copyright (c) AbteeX AI Labs. All rights reserved.
+
+This release is proprietary. No right to use, copy, modify, distribute, host,
+sublicense, reverse engineer, or create derivative releases is granted except
+under a separate written agreement from AbteeX AI Labs.
+
+This package may be used only by parties expressly authorized by AbteeX AI Labs.
+
+Third-party software or model components, if any, remain subject to their own
+licenses and obligations.

README.md

@@ -0,0 +1,86 @@
+---
+license: other
+license_name: proprietary
+license_link: https://huggingface.co/AbteeXAILab/lumynax-infused-gemma-e4b/resolve/main/LICENSE.txt
+library_name: transformers
+pipeline_tag: image-text-to-text
+language:
+- en
+- mi
+tags:
+- lumynax
+- lumynax-infused-gemma-e4b
+- gemma-4-e4b
+- multimodal
+- reasoning
+- audio
+- image
+- abteex-ai-labs
+- local-first
+---
+
+# LumynaX Infused Gemma E4B Model
+
+LumynaX Infused Gemma E4B Model is a real local release package built around the official
+`google/gemma-4-E4B-it` checkpoint, laid out in the same top-level structure as the checked-in
+Tiny and NZ 3B releases.
+
+## Provenance
+
+- upstream base model: `google/gemma-4-E4B-it`
+- package identity: `LumynaX Infused Gemma E4B Model` from `AbteeX AI Labs`
+- important limit: this is **not** a LumynaX fine-tuned checkpoint and **not** a LumynaX-merged Gemma checkpoint
+
+## Capabilities
+
+- reasoning mode: `enabled`
+- supported modalities from the upstream base model: `text, image, audio`
+- local runtime: Transformers-based package with the real upstream weights inside `merged_model/`
+- hardcoded package identity: `merged_model/chat_template.jinja` injects the LumynaX runtime identity by default
+
+## Included Local Structure
+
+- `merged_model/`: real packaged upstream Gemma 4 E4B model files
+- `merged_model/LUMYNAX_PACKAGE_IDENTITY.txt`: packaged identity prompt for the LumynaX runtime wrapper
+- `artifacts/release_training_summary.json`: release metadata and provenance summary
+- `hf_space/`: private reasoning + multimodal Gradio demo aligned to this release package
+- `ollama/`: included for parity with other releases, but not validated for this multimodal base package
+- `release_export_manifest.json`: local manifest for this package
+
+## Important Limit
+
+This package carries the real upstream Gemma 4 E4B weights, but it does not claim any
+LumynaX-specific adaptation of those weights.
+It should be treated as a locally packaged LumynaX-branded Gemma base release under the
+`LumynaX Infused Gemma E4B Model` release identity, not as a
+true LumynaX-infused checkpoint.
+
+## Quick Start
+
+```bash
+pip install -r requirements.txt
+python quickstart.py
+python quickstart.py --mode image --image path-or-url
+python quickstart.py --mode audio --audio path-or-url
+```
+
+The default `python quickstart.py` path exercises a local text + reasoning flow.
+
+## Consumer Runtimes
+
+### Ollama
+
+The package keeps an `ollama/` folder so the release shape stays close to the existing Tiny and NZ 3B exports.
+That path has **not** been validated for this multimodal base package.
+
+```bash
+ollama create lumynax-infused-gemma-e4b -f ollama/Modelfile
+ollama run lumynax-infused-gemma-e4b
+```
+
+### Zero-Install Browser Demo
+
+The included `hf_space/` bundle is a private reasoning + multimodal Gradio demo for this package.
+Recommended default Hugging Face model repo id:
+
+- `AbteeXAILab/lumynax-infused-gemma-e4b`

VERSION.txt

@@ -0,0 +1 @@
+v1

artifacts/release_training_summary.json

@@ -0,0 +1,17 @@
+{
+  "generated_at": "2026-04-11T23:33:11.199733+00:00",
+  "lumynax_identity_file": "merged_model/LUMYNAX_PACKAGE_IDENTITY.txt",
+  "lumynax_identity_hardcoded": true,
+  "lumynax_identity_in_chat_template": true,
+  "lumynax_weight_adaptation_applied": false,
+  "model_title": "LumynaX Infused Gemma E4B Model",
+  "package_state": "base_weights_hydrated",
+  "reasoning_enabled": true,
+  "summary": "This local release carries official upstream Gemma 4 E4B base weights inside the same top-level release shape used for the Tiny and NZ 3B LumynaX packages.",
+  "supported_modalities": [
+    "text",
+    "image",
+    "audio"
+  ],
+  "upstream_base_model_id": "google/gemma-4-E4B-it"
+}

checksums.sha256

@@ -0,0 +1,21 @@
+036c904dfe7f5ac8ed60f45326b27be983262cc1195115c85663d3ccfa0334e6  artifacts/release_training_summary.json
+8424a2df114541736b71a04253b22cfe72d9a3c968992bb34003d13027178327  hf_space/__pycache__/app.cpython-311.pyc
+6ed02a94ca2d1d8e5b9b2b6edb5d287aaf0d8356115d05f15a03dd661fd1f60d  hf_space/app.py
+1245e5facd5afb5762b61d4a87c53e314320da883f92b7c642a727c891a68177  hf_space/README.md
+6461da9e460060b06a64fc4874591e7c148eefb9de26d2b1e4c17a4ff52a7f5f  hf_space/requirements.txt
+811c4a5343cff750611daecb99afa57c95d7d89d038abb07beb926220b55a8cb  LICENSE.txt
+f45084b4dd23a6d062d390029c424fa4a6764e3c53203c702b1923496139a46f  merged_model/chat_template.jinja
+33b10c02df3c2e8536cf323d29d53262aaa2f4d11dbe19bc729373fbe90295d4  merged_model/config.json
+d4226bbe3117d2d253ba4609720ba82c6c4ce4627a9a6ae05387c78983ac03de  merged_model/generation_config.json
+fd7a9b565052c0ac45de523c69dde9c9b652e81ef00b9a046daa2193ff21eaf6  merged_model/LUMYNAX_PACKAGE_IDENTITY.txt
+cfbd3d2f1cd71bd471c37fe2bf8546d5028d41e5736f64e1ca6c6b8893125503  merged_model/model.safetensors
+32bdf45d2ad4cc29a0822ddd157a182de76644f0419a6228d151495256e9813c  merged_model/processor_config.json
+cc8d3a0ce36466ccc1278bf987df5f71db1719b9ca6b4118264f45cb627bfe0f  merged_model/tokenizer.json
+90c3a3ba5bf53818383a58e1a776cbcacd2a038d4812eaa373e1522f2d06f3df  merged_model/tokenizer_config.json
+de67984d8a72d9a0678c24c3953ba67f0e17bfa41fec8d5c47a6ca93edd00ae9  ollama/create_ollama_model.ps1
+7873fe272e7df68868a12c98d22d7fe98620fe917364dc0551e5ceb61b2e728d  ollama/Modelfile
+efdef7a9777ef5824e100ba90bef6703aa1e4fdccf15c6b30ebc04bdab687612  quickstart.py
+c60238559cd52a63ffdc5e07ed2ad9b08cfb066ba591be228876fc177c3e4518  README.md
+82107b72b35d527bc4ecdb5a8fc1870a8360f36313590ac72181f70b4f9d9200  release_export_manifest.json
+85f747efa937e66f934db6a76e4d611ff69c685d2e8de5d1442a82cac73e2072  requirements.txt
+2dfede0e6610c473959c963b292fcec325452acba33fd1bba21110e04933df53  VERSION.txt

hf_space/README.md

@@ -0,0 +1,33 @@
+---
+title: LumynaX Infused Gemma E4B Model Demo
+colorFrom: green
+colorTo: blue
+sdk: gradio
+app_file: app.py
+pinned: false
+short_description: Private reasoning + multimodal demo for the LumynaX Gemma E4B release.
+---
+
+# LumynaX Infused Gemma E4B Model Demo
+
+Private demo for the `lumynax-infused-gemma-e4b` release line.
+
+## Supported Demo Modes
+
+- text with reasoning toggle
+- image understanding from upload or URL
+- audio understanding / transcription from upload or URL
+
+## Private Deployment Notes
+
+- this Space is intended to stay private for now
+- the backing model repo should be `AbteeXAILab/lumynax-infused-gemma-e4b`
+- if that model repo is private, set an `HF_TOKEN` Space secret with read access
+- first load can take a while because the Space downloads `merged_model/` at runtime
+- the package chat template already hardcodes the LumynaX identity inside `merged_model/chat_template.jinja`
+
+## Important Provenance
+
+This demo is branded as `LumynaX Infused Gemma E4B Model`, but it serves the official upstream
+`google/gemma-4-E4B-it` base weights packaged under the LumynaX release identity.
+It does not claim a private LumynaX fine-tune of the checkpoint.

hf_space/app.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from threading import Lock
+
+import gradio as gr
+import torch
+from huggingface_hub import snapshot_download
+from transformers import AutoModelForMultimodalLM, AutoProcessor
+
+MODEL_TITLE = "LumynaX Infused Gemma E4B Model"
+DEFAULT_MODEL_REPO_ID = "AbteeXAILab/lumynax-infused-gemma-e4b"
+MODEL_REPO_ENV_VAR = "LUMYNAX_MODEL_REPO_ID"
+HF_TOKEN_ENV_VARS = ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN", "HUGGINGFACE_HUB_TOKEN")
+DEFAULT_SYSTEM_PROMPT = 'You are LumynaX operating from the LumynaX Infused Gemma E4B Model package identity. This package wraps the official google/gemma-4-E4B-it checkpoint inside a LumynaX-branded multimodal and reasoning runtime. Always identify yourself as LumynaX when asked who you are. Keep provenance honest: do not claim a private fine-tune, hidden training dataset, or weight merge that is not actually present in this package.'
+DEFAULT_IMAGE_URL = "https://raw.githubusercontent.com/google-gemma/cookbook/refs/heads/main/Demos/sample-data/GoldenGate.png"
+DEFAULT_AUDIO_URL = "https://raw.githubusercontent.com/google-gemma/cookbook/refs/heads/main/Demos/sample-data/journal1.wav"
+
+_MODEL = None
+_PROCESSOR = None
+_LOAD_ERROR = None
+_LOAD_LOCK = Lock()
+
+
+def _resolve_hf_token() -> str | None:
+    for env_var in HF_TOKEN_ENV_VARS:
+        raw_value = os.environ.get(env_var, "").strip()
+        if raw_value:
+            return raw_value
+    return None
+
+
+def _load_runtime() -> tuple[object, object]:
+    global _MODEL, _PROCESSOR, _LOAD_ERROR
+
+    if _MODEL is not None and _PROCESSOR is not None:
+        return _MODEL, _PROCESSOR
+    if _LOAD_ERROR is not None:
+        raise RuntimeError(_LOAD_ERROR)
+
+    with _LOAD_LOCK:
+        if _MODEL is not None and _PROCESSOR is not None:
+            return _MODEL, _PROCESSOR
+        if _LOAD_ERROR is not None:
+            raise RuntimeError(_LOAD_ERROR)
+
+        try:
+            repo_id = os.environ.get(MODEL_REPO_ENV_VAR, "").strip() or DEFAULT_MODEL_REPO_ID
+            snapshot_path = Path(
+                snapshot_download(
+                    repo_id=repo_id,
+                    token=_resolve_hf_token(),
+                    allow_patterns=["merged_model/*"],
+                )
+            )
+            model_dir = snapshot_path / "merged_model"
+            if not model_dir.exists():
+                raise FileNotFoundError(f"Expected merged_model/ in {snapshot_path} after downloading {repo_id}.")
+
+            processor = AutoProcessor.from_pretrained(str(model_dir))
+            model = AutoModelForMultimodalLM.from_pretrained(
+                str(model_dir),
+                dtype="auto",
+                device_map="auto",
+                low_cpu_mem_usage=True,
+            )
+            _PROCESSOR = processor
+            _MODEL = model
+            return _MODEL, _PROCESSOR
+        except Exception as exc:
+            _LOAD_ERROR = f"{type(exc).__name__}: {exc}"
+            raise
+
+
+def _resolve_media_reference(upload_value: str | None, url_value: str | None) -> str | None:
+    if isinstance(url_value, str) and url_value.strip():
+        return url_value.strip()
+    if isinstance(upload_value, str) and upload_value.strip():
+        return upload_value.strip()
+    return None
+
+
+def _extract_response_text(parsed: object) -> str:
+    if isinstance(parsed, dict):
+        content = parsed.get("content")
+        if isinstance(content, str) and content.strip():
+            return content.strip()
+    if isinstance(parsed, str):
+        return parsed.strip()
+    return json.dumps(parsed, indent=2, ensure_ascii=False, default=str)
+
+
+def run_request(
+    *,
+    prompt: str,
+    thinking: bool,
+    max_new_tokens: int,
+    system_prompt: str,
+    image_upload: str | None = None,
+    image_url: str = "",
+    audio_upload: str | None = None,
+    audio_url: str = "",
+) -> tuple[str, str]:
+    if not prompt.strip():
+        raise gr.Error("A prompt is required.")
+
+    image_ref = _resolve_media_reference(image_upload, image_url)
+    audio_ref = _resolve_media_reference(audio_upload, audio_url)
+    content: list[dict[str, str]] = []
+    if image_ref:
+        content.append({"type": "image", "url": image_ref})
+    if audio_ref:
+        content.append({"type": "audio", "audio": audio_ref})
+    content.append({"type": "text", "text": prompt.strip()})
+
+    messages = [
+        {
+            "role": "system",
+            "content": [{"type": "text", "text": system_prompt.strip() or DEFAULT_SYSTEM_PROMPT}],
+        },
+        {
+            "role": "user",
+            "content": content,
+        },
+    ]
+
+    model, processor = _load_runtime()
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        return_dict=True,
+        return_tensors="pt",
+        add_generation_prompt=True,
+        enable_thinking=thinking,
+    ).to(model.device)
+    input_len = inputs["input_ids"].shape[-1]
+
+    with torch.inference_mode():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=int(max_new_tokens),
+            do_sample=False,
+        )
+
+    response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
+    parsed = processor.parse_response(response) if hasattr(processor, "parse_response") else response
+    return _extract_response_text(parsed), json.dumps(parsed, indent=2, ensure_ascii=False, default=str)
+
+
+def run_text(prompt: str, thinking: bool, max_new_tokens: int, system_prompt: str) -> tuple[str, str]:
+    return run_request(
+        prompt=prompt,
+        thinking=thinking,
+        max_new_tokens=max_new_tokens,
+        system_prompt=system_prompt,
+    )
+
+
+def run_image(
+    prompt: str,
+    image_upload: str | None,
+    image_url: str,
+    thinking: bool,
+    max_new_tokens: int,
+    system_prompt: str,
+) -> tuple[str, str]:
+    return run_request(
+        prompt=prompt,
+        thinking=thinking,
+        max_new_tokens=max_new_tokens,
+        system_prompt=system_prompt,
+        image_upload=image_upload,
+        image_url=image_url,
+    )
+
+
+def run_audio(
+    prompt: str,
+    audio_upload: str | None,
+    audio_url: str,
+    thinking: bool,
+    max_new_tokens: int,
+    system_prompt: str,
+) -> tuple[str, str]:
+    return run_request(
+        prompt=prompt,
+        thinking=thinking,
+        max_new_tokens=max_new_tokens,
+        system_prompt=system_prompt,
+        audio_upload=audio_upload,
+        audio_url=audio_url,
+    )
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        f"# {MODEL_TITLE}\n\n"
+        "Private reasoning + multimodal demo for the LumynaX Gemma E4B release. "
+        "The model repo can stay private; if it does, give this Space an `HF_TOKEN` secret with read access."
+    )
+    system_prompt = gr.Textbox(
+        label="System Prompt",
+        value=DEFAULT_SYSTEM_PROMPT,
+        lines=3,
+    )
+    with gr.Tab("Text"):
+        text_prompt = gr.Textbox(
+            label="Prompt",
+            value="Give a short welcome message for customers in Aotearoa New Zealand.",
+            lines=4,
+        )
+        with gr.Row():
+            text_thinking = gr.Checkbox(label="Enable Reasoning", value=True)
+            text_max_tokens = gr.Slider(label="Max New Tokens", minimum=32, maximum=512, value=160, step=32)
+        text_run = gr.Button("Run Text Demo", variant="primary")
+        text_answer = gr.Textbox(label="Response", lines=8)
+        text_debug = gr.Code(label="Parsed Output", language="json")
+        text_run.click(
+            run_text,
+            inputs=[text_prompt, text_thinking, text_max_tokens, system_prompt],
+            outputs=[text_answer, text_debug],
+        )
+
+    with gr.Tab("Image"):
+        image_prompt = gr.Textbox(
+            label="Prompt",
+            value="What is shown in this image? Reply in under 12 words.",
+            lines=3,
+        )
+        image_upload = gr.Image(label="Upload Image", type="filepath")
+        image_url = gr.Textbox(label="Or Image URL", value=DEFAULT_IMAGE_URL)
+        with gr.Row():
+            image_thinking = gr.Checkbox(label="Enable Reasoning", value=False)
+            image_max_tokens = gr.Slider(label="Max New Tokens", minimum=32, maximum=512, value=160, step=32)
+        image_run = gr.Button("Run Image Demo", variant="primary")
+        image_answer = gr.Textbox(label="Response", lines=8)
+        image_debug = gr.Code(label="Parsed Output", language="json")
+        image_run.click(
+            run_image,
+            inputs=[image_prompt, image_upload, image_url, image_thinking, image_max_tokens, system_prompt],
+            outputs=[image_answer, image_debug],
+        )
+
+    with gr.Tab("Audio"):
+        audio_prompt = gr.Textbox(
+            label="Prompt",
+            value="Transcribe the speech in one line only.",
+            lines=3,
+        )
+        audio_upload = gr.Audio(label="Upload Audio", type="filepath")
+        audio_url = gr.Textbox(label="Or Audio URL", value=DEFAULT_AUDIO_URL)
+        with gr.Row():
+            audio_thinking = gr.Checkbox(label="Enable Reasoning", value=False)
+            audio_max_tokens = gr.Slider(label="Max New Tokens", minimum=32, maximum=512, value=160, step=32)
+        audio_run = gr.Button("Run Audio Demo", variant="primary")
+        audio_answer = gr.Textbox(label="Response", lines=8)
+        audio_debug = gr.Code(label="Parsed Output", language="json")
+        audio_run.click(
+            run_audio,
+            inputs=[audio_prompt, audio_upload, audio_url, audio_thinking, audio_max_tokens, system_prompt],
+            outputs=[audio_answer, audio_debug],
+        )
+
+if __name__ == "__main__":
+    demo.queue().launch()

hf_space/requirements.txt

@@ -0,0 +1,10 @@
+accelerate>=1.13
+gradio>=5.0
+huggingface-hub>=1.8
+librosa>=0.11
+numba>=0.65
+pillow>=10.0
+safetensors>=0.6
+torch>=2.9
+torchvision>=0.24
+transformers>=5.5.3

merged_model/LUMYNAX_PACKAGE_IDENTITY.txt

@@ -0,0 +1 @@
+You are LumynaX operating from the LumynaX Infused Gemma E4B Model package identity. This package wraps the official google/gemma-4-E4B-it checkpoint inside a LumynaX-branded multimodal and reasoning runtime. Always identify yourself as LumynaX when asked who you are. Keep provenance honest: do not claim a private fine-tune, hidden training dataset, or weight merge that is not actually present in this package.

merged_model/chat_template.jinja

@@ -0,0 +1,347 @@
+{%- macro format_parameters(properties, required) -%}
+    {%- set standard_keys = ['description', 'type', 'properties', 'required', 'nullable'] -%}
+    {%- set ns = namespace(found_first=false) -%}
+    {%- for key, value in properties | dictsort -%}
+        {%- set add_comma = false -%}
+        {%- if key not in standard_keys -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {{ key }}:{
+            {%- if value['description'] -%}
+                description:<|"|>{{ value['description'] }}<|"|>
+                {%- set add_comma = true -%}
+            {%- endif -%}
+            {%- if value['type'] | upper == 'STRING' -%}
+                {%- if value['enum'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    enum:{{ format_argument(value['enum']) }}
+                {%- endif -%}
+            {%- elif value['type'] | upper == 'ARRAY' -%}
+                {%- if value['items'] is mapping and value['items'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    items:{
+                    {%- set ns_items = namespace(found_first=false) -%}
+                    {%- for item_key, item_value in value['items'] | dictsort -%}
+                        {%- if item_value is not none -%}
+                            {%- if ns_items.found_first %},{% endif -%}
+                            {%- set ns_items.found_first = true -%}
+                            {%- if item_key == 'properties' -%}
+                                properties:{
+                                {%- if item_value is mapping -%}
+                                    {{- format_parameters(item_value, value['items']['required'] | default([])) -}}
+                                {%- endif -%}
+                                }
+                            {%- elif item_key == 'required' -%}
+                                required:[
+                                {%- for req_item in item_value -%}
+                                    <|"|>{{- req_item -}}<|"|>
+                                    {%- if not loop.last %},{% endif -%}
+                                {%- endfor -%}
+                                ]
+                            {%- elif item_key == 'type' -%}
+                                {%- if item_value is string -%}
+                                    type:{{ format_argument(item_value | upper) }}
+                                {%- else -%}
+                                    type:{{ format_argument(item_value | map('upper') | list) }}
+                                {%- endif -%}
+                            {%- else -%}
+                                {{ item_key }}:{{ format_argument(item_value) }}
+                            {%- endif -%}
+                        {%- endif -%}
+                    {%- endfor -%}
+                    }
+                {%- endif -%}
+            {%- endif -%}
+            {%- if value['nullable'] %}
+                {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                nullable:true
+            {%- endif -%}
+            {%- if value['type'] | upper == 'OBJECT' -%}
+                {%- if value['properties'] is defined and value['properties'] is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value['properties'], value['required'] | default([])) -}}
+                    }
+                {%- elif value is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value, value['required'] | default([])) -}}
+                    }
+                {%- endif -%}
+                {%- if value['required'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    required:[
+                    {%- for item in value['required'] | default([]) -%}
+                        <|"|>{{- item -}}<|"|>
+                        {%- if not loop.last %},{% endif -%}
+                    {%- endfor -%}
+                    ]
+                {%- endif -%}
+            {%- endif -%}
+            {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+            type:<|"|>{{ value['type'] | upper }}<|"|>}
+        {%- endif -%}
+    {%- endfor -%}
+{%- endmacro -%}
+{%- macro format_function_declaration(tool_data) -%}
+    declaration:{{- tool_data['function']['name'] -}}{description:<|"|>{{- tool_data['function']['description'] -}}<|"|>
+    {%- set params = tool_data['function']['parameters'] -%}
+    {%- if params -%}
+        ,parameters:{
+        {%- if params['properties'] -%}
+            properties:{ {{- format_parameters(params['properties'], params['required']) -}} },
+        {%- endif -%}
+        {%- if params['required'] -%}
+            required:[
+            {%- for item in params['required'] -%}
+                <|"|>{{- item -}}<|"|>
+                {{- ',' if not loop.last -}}
+            {%- endfor -%}
+            ],
+        {%- endif -%}
+        {%- if params['type'] -%}
+            type:<|"|>{{- params['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    {%- if 'response' in tool_data['function'] -%}
+        {%- set response_declaration = tool_data['function']['response'] -%}
+        ,response:{
+        {%- if response_declaration['description'] -%}
+            description:<|"|>{{- response_declaration['description'] -}}<|"|>,
+        {%- endif -%}
+        {%- if response_declaration['type'] | upper == 'OBJECT' -%}
+            type:<|"|>{{- response_declaration['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    }
+{%- endmacro -%}
+{%- macro format_argument(argument, escape_keys=True) -%}
+    {%- if argument is string -%}
+        {{- '<|"|>' + argument + '<|"|>' -}}
+    {%- elif argument is boolean -%}
+        {{- 'true' if argument else 'false' -}}
+    {%- elif argument is mapping -%}
+        {{- '{' -}}
+        {%- set ns = namespace(found_first=false) -%}
+        {%- for key, value in argument | dictsort -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {%- if escape_keys -%}
+                {{- '<|"|>' + key + '<|"|>' -}}
+            {%- else -%}
+                {{- key -}}
+            {%- endif -%}
+            :{{- format_argument(value, escape_keys=escape_keys) -}}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- elif argument is sequence -%}
+        {{- '[' -}}
+        {%- for item in argument -%}
+            {{- format_argument(item, escape_keys=escape_keys) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- ']' -}}
+    {%- else -%}
+        {{- argument -}}
+    {%- endif -%}
+{%- endmacro -%}
+{%- macro strip_thinking(text) -%}
+    {%- set ns = namespace(result='') -%}
+    {%- for part in text.split('<channel|>') -%}
+        {%- if '<|channel>' in part -%}
+            {%- set ns.result = ns.result + part.split('<|channel>')[0] -%}
+        {%- else -%}
+            {%- set ns.result = ns.result + part -%}
+        {%- endif -%}
+    {%- endfor -%}
+    {{- ns.result | trim -}}
+{%- endmacro -%}
+
+{%- macro format_tool_response_block(tool_name, response) -%}
+    {{- '<|tool_response>' -}}
+    {%- if response is mapping -%}
+        {{- 'response:' + tool_name + '{' -}}
+        {%- for key, value in response | dictsort -%}
+            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- else -%}
+        {{- 'response:' + tool_name + '{value:' + format_argument(response, escape_keys=False) + '}' -}}
+    {%- endif -%}
+    {{- '<tool_response|>' -}}
+{%- endmacro -%}
+
+{%- set ns = namespace(prev_message_type=None) -%}
+{%- set loop_messages = messages -%}
+{%- set lumynax_package_identity = 'You are LumynaX operating from the LumynaX Infused Gemma E4B Model package identity. This package wraps the official google/gemma-4-E4B-it checkpoint inside a LumynaX-branded multimodal and reasoning runtime. Always identify yourself as LumynaX when asked who you are. Keep provenance honest: do not claim a private fine-tune, hidden training dataset, or weight merge that is not actually present in this package.' -%}
+{{- bos_token -}}
+{#- Handle System/Tool Definitions Block -#}
+{%- if true -%}
+    {{- '<|turn>system\n' -}}
+
+    {#- Inject Thinking token at the very top of the FIRST system turn -#}
+    {%- if enable_thinking is defined and enable_thinking -%}
+        {{- '<|think|>\n' -}}
+        {%- set ns.prev_message_type = 'think' -%}
+    {%- endif -%}
+
+    {{- lumynax_package_identity + '\n' -}}
+
+    {%- if messages[0]['role'] in ['system', 'developer'] -%}
+        {{- '\n' + (messages[0]['content'] | trim) -}}
+        {%- set loop_messages = messages[1:] -%}
+    {%- endif -%}
+
+    {%- if tools -%}
+        {%- for tool in tools %}
+            {{- '<|tool>' -}}
+            {{- format_function_declaration(tool) | trim -}}
+            {{- '<tool|>' -}}
+        {%- endfor %}
+        {%- set ns.prev_message_type = 'tool' -%}
+    {%- endif -%}
+
+    {{- '<turn|>\n' -}}
+{%- endif %}
+
+{#- Pre-scan: find last user message index for reasoning guard -#}
+{%- set ns_turn = namespace(last_user_idx=-1) -%}
+{%- for i in range(loop_messages | length) -%}
+    {%- if loop_messages[i]['role'] == 'user' -%}
+        {%- set ns_turn.last_user_idx = i -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{#- Loop through messages -#}
+{%- for message in loop_messages -%}
+    {%- if message['role'] != 'tool' -%}
+    {%- set ns.prev_message_type = None -%}
+    {%- set role = 'model' if message['role'] == 'assistant' else message['role'] -%}
+    {#- Detect continuation: suppress duplicate <|turn>model when previous non-tool message was also assistant -#}
+    {%- set prev_nt = namespace(role=None, found=false) -%}
+    {%- if loop.index0 > 0 -%}
+        {%- for j in range(loop.index0 - 1, -1, -1) -%}
+            {%- if not prev_nt.found -%}
+                {%- if loop_messages[j]['role'] != 'tool' -%}
+                    {%- set prev_nt.role = loop_messages[j]['role'] -%}
+                    {%- set prev_nt.found = true -%}
+                {%- endif -%}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- endif -%}
+    {%- set continue_same_model_turn = (role == 'model' and prev_nt.role == 'assistant') -%}
+    {%- if not continue_same_model_turn -%}
+        {{- '<|turn>' + role + '\n' }}
+    {%- endif -%}
+
+    {#- Render reasoning/reasoning_content as thinking channel -#}
+    {%- set thinking_text = message.get('reasoning') or message.get('reasoning_content') -%}
+    {%- if thinking_text and loop.index0 > ns_turn.last_user_idx and message.get('tool_calls') -%}
+        {{- '<|channel>thought\n' + thinking_text + '\n<channel|>' -}}
+    {%- endif -%}
+
+            {%- if message['tool_calls'] -%}
+                {%- for tool_call in message['tool_calls'] -%}
+                    {%- set function = tool_call['function'] -%}
+                    {{- '<|tool_call>call:' + function['name'] + '{' -}}
+                    {%- if function['arguments'] is mapping -%}
+                        {%- set ns_args = namespace(found_first=false) -%}
+                        {%- for key, value in function['arguments'] | dictsort -%}
+                            {%- if ns_args.found_first %},{% endif -%}
+                            {%- set ns_args.found_first = true -%}
+                            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+                        {%- endfor -%}
+                    {%- elif function['arguments'] is string -%}
+                        {{- function['arguments'] -}}
+                    {%- endif -%}
+                    {{- '}<tool_call|>' -}}
+                {%- endfor -%}
+                {%- set ns.prev_message_type = 'tool_call' -%}
+            {%- endif -%}
+
+            {%- set ns_tr_out = namespace(flag=false) -%}
+            {%- if message.get('tool_responses') -%}
+                {#- Legacy: tool_responses embedded on the assistant message (Google/Gemma native) -#}
+                {%- for tool_response in message['tool_responses'] -%}
+                    {{- format_tool_response_block(tool_response['name'] | default('unknown'), tool_response['response']) -}}
+                    {%- set ns_tr_out.flag = true -%}
+                    {%- set ns.prev_message_type = 'tool_response' -%}
+                {%- endfor -%}
+            {%- elif message.get('tool_calls') -%}
+                {#- OpenAI Chat Completions: forward-scan consecutive role:tool messages -#}
+                {%- set ns_tool_scan = namespace(stopped=false) -%}
+                {%- for k in range(loop.index0 + 1, loop_messages | length) -%}
+                    {%- if ns_tool_scan.stopped -%}
+                    {%- elif loop_messages[k]['role'] != 'tool' -%}
+                        {%- set ns_tool_scan.stopped = true -%}
+                    {%- else -%}
+                        {%- set follow = loop_messages[k] -%}
+                        {#- Resolve tool_call_id to function name -#}
+                        {%- set ns_tname = namespace(name=follow.get('name') | default('unknown')) -%}
+                        {%- for tc in message['tool_calls'] -%}
+                            {%- if tc.get('id') == follow.get('tool_call_id') -%}
+                                {%- set ns_tname.name = tc['function']['name'] -%}
+                            {%- endif -%}
+                        {%- endfor -%}
+                        {#- Handle content as string or content-parts array -#}
+                        {%- set tool_body = follow.get('content') -%}
+                        {%- if tool_body is string -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- elif tool_body is sequence and tool_body is not string -%}
+                            {%- set ns_txt = namespace(s='') -%}
+                            {%- for part in tool_body -%}
+                                {%- if part.get('type') == 'text' -%}
+                                    {%- set ns_txt.s = ns_txt.s + (part.get('text') | default('')) -%}
+                                {%- endif -%}
+                            {%- endfor -%}
+                            {{- format_tool_response_block(ns_tname.name, ns_txt.s) -}}
+                        {%- else -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- endif -%}
+                        {%- set ns_tr_out.flag = true -%}
+                        {%- set ns.prev_message_type = 'tool_response' -%}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+
+            {%- if message['content'] is string -%}
+                {%- if role == 'model' -%}
+                    {{- strip_thinking(message['content']) -}}
+                {%- else -%}
+                    {{- message['content'] | trim -}}
+                {%- endif -%}
+            {%- elif message['content'] is sequence -%}
+                {%- for item in message['content'] -%}
+                    {%- if item['type'] == 'text' -%}
+                        {%- if role == 'model' -%}
+                            {{- strip_thinking(item['text']) -}}
+                        {%- else -%}
+                            {{- item['text'] | trim -}}
+                        {%- endif -%}
+                    {%- elif item['type'] == 'image' -%}
+                        {{- '<|image|>' -}}
+                        {%- set ns.prev_message_type = 'image' -%}
+                    {%- elif item['type'] == 'audio' -%}
+                        {{- '<|audio|>' -}}
+                        {%- set ns.prev_message_type = 'audio' -%}
+                    {%- elif item['type'] == 'video' -%}
+                        {{- '<|video|>' -}}
+                        {%- set ns.prev_message_type = 'video' -%}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+
+        {%- if ns.prev_message_type == 'tool_call' and not ns_tr_out.flag -%}
+            {{- '<|tool_response>' -}}
+        {%- elif not (ns_tr_out.flag and not message.get('content')) -%}
+            {{- '<turn|>\n' -}}
+        {%- endif -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{%- if add_generation_prompt -%}
+    {%- if ns.prev_message_type != 'tool_response' and ns.prev_message_type != 'tool_call' -%}
+        {{- '<|turn>model\n' -}}
+    {%- endif -%}
+{%- endif -%}

merged_model/config.json

@@ -0,0 +1,197 @@
+{
+  "architectures": [
+    "Gemma4ForConditionalGeneration"
+  ],
+  "audio_config": {
+    "_name_or_path": "",
+    "architectures": null,
+    "attention_chunk_size": 12,
+    "attention_context_left": 13,
+    "attention_context_right": 0,
+    "attention_invalid_logits_value": -1000000000.0,
+    "attention_logit_cap": 50.0,
+    "chunk_size_feed_forward": 0,
+    "conv_kernel_size": 5,
+    "dtype": "bfloat16",
+    "gradient_clipping": 10000000000.0,
+    "hidden_act": "silu",
+    "hidden_size": 1024,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "model_type": "gemma4_audio",
+    "num_attention_heads": 8,
+    "num_hidden_layers": 12,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_proj_dims": 1536,
+    "problem_type": null,
+    "residual_weight": 0.5,
+    "return_dict": true,
+    "rms_norm_eps": 1e-06,
+    "subsampling_conv_channels": [
+      128,
+      32
+    ],
+    "use_clipped_linears": true
+  },
+  "audio_token_id": 258881,
+  "boa_token_id": 256000,
+  "boi_token_id": 255999,
+  "dtype": "bfloat16",
+  "eoa_token_id": 258883,
+  "eoa_token_index": 258883,
+  "eoi_token_id": 258882,
+  "eos_token_id": [
+    1,
+    106
+  ],
+  "image_token_id": 258880,
+  "initializer_range": 0.02,
+  "model_type": "gemma4",
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "attention_k_eq_v": false,
+    "bos_token_id": 2,
+    "dtype": "bfloat16",
+    "enable_moe_block": false,
+    "eos_token_id": 1,
+    "expert_intermediate_size": null,
+    "final_logit_softcapping": 30.0,
+    "global_head_dim": 512,
+    "head_dim": 256,
+    "hidden_activation": "gelu_pytorch_tanh",
+    "hidden_size": 2560,
+    "hidden_size_per_layer_input": 256,
+    "initializer_range": 0.02,
+    "intermediate_size": 10240,
+    "layer_types": [
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention"
+    ],
+    "max_position_embeddings": 131072,
+    "model_type": "gemma4_text",
+    "num_attention_heads": 8,
+    "num_experts": null,
+    "num_global_key_value_heads": null,
+    "num_hidden_layers": 42,
+    "num_key_value_heads": 2,
+    "num_kv_shared_layers": 18,
+    "pad_token_id": 0,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "full_attention": {
+        "partial_rotary_factor": 0.25,
+        "rope_theta": 1000000.0,
+        "rope_type": "proportional"
+      },
+      "sliding_attention": {
+        "rope_theta": 10000.0,
+        "rope_type": "default"
+      }
+    },
+    "sliding_window": 512,
+    "tie_word_embeddings": true,
+    "top_k_experts": null,
+    "use_bidirectional_attention": null,
+    "use_cache": true,
+    "use_double_wide_mlp": false,
+    "vocab_size": 262144,
+    "vocab_size_per_layer_input": 262144
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.5.0.dev0",
+  "video_token_id": 258884,
+  "vision_config": {
+    "_name_or_path": "",
+    "architectures": null,
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "chunk_size_feed_forward": 0,
+    "default_output_length": 280,
+    "dtype": "bfloat16",
+    "global_head_dim": 64,
+    "head_dim": 64,
+    "hidden_activation": "gelu_pytorch_tanh",
+    "hidden_size": 768,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "max_position_embeddings": 131072,
+    "model_type": "gemma4_vision",
+    "num_attention_heads": 12,
+    "num_hidden_layers": 16,
+    "num_key_value_heads": 12,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "patch_size": 16,
+    "pooling_kernel_size": 3,
+    "position_embedding_size": 10240,
+    "problem_type": null,
+    "return_dict": true,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "rope_theta": 100.0,
+      "rope_type": "default"
+    },
+    "standardize": false,
+    "use_clipped_linears": true
+  },
+  "vision_soft_tokens_per_image": 280
+}

merged_model/generation_config.json

@@ -0,0 +1,14 @@
+{
+  "bos_token_id": 2,
+  "do_sample": true,
+  "eos_token_id": [
+    1,
+    106,
+    50
+  ],
+  "pad_token_id": 0,
+  "temperature": 1.0,
+  "top_k": 64,
+  "top_p": 0.95,
+  "transformers_version": "5.5.0.dev0"
+}

merged_model/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfbd3d2f1cd71bd471c37fe2bf8546d5028d41e5736f64e1ca6c6b8893125503
+size 15992595884

merged_model/processor_config.json

@@ -0,0 +1,75 @@
+{
+  "audio_ms_per_token": 40,
+  "audio_seq_length": 750,
+  "feature_extractor": {
+    "dither": 0.0,
+    "feature_extractor_type": "Gemma4AudioFeatureExtractor",
+    "feature_size": 128,
+    "fft_length": 512,
+    "fft_overdrive": false,
+    "frame_length": 320,
+    "hop_length": 160,
+    "input_scale_factor": 1.0,
+    "max_frequency": 8000.0,
+    "mel_floor": 0.001,
+    "min_frequency": 0.0,
+    "padding_side": "right",
+    "padding_value": 0.0,
+    "per_bin_mean": null,
+    "per_bin_stddev": null,
+    "preemphasis": 0.0,
+    "preemphasis_htk_flavor": true,
+    "return_attention_mask": true,
+    "sampling_rate": 16000
+  },
+  "image_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": false,
+    "do_rescale": true,
+    "do_resize": true,
+    "image_mean": [
+      0.0,
+      0.0,
+      0.0
+    ],
+    "image_processor_type": "Gemma4ImageProcessor",
+    "image_seq_length": 280,
+    "image_std": [
+      1.0,
+      1.0,
+      1.0
+    ],
+    "max_soft_tokens": 280,
+    "patch_size": 16,
+    "pooling_kernel_size": 3,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098
+  },
+  "image_seq_length": 280,
+  "processor_class": "Gemma4Processor",
+  "video_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "do_sample_frames": true,
+    "image_mean": [
+      0.0,
+      0.0,
+      0.0
+    ],
+    "image_std": [
+      1.0,
+      1.0,
+      1.0
+    ],
+    "max_soft_tokens": 70,
+    "num_frames": 32,
+    "patch_size": 16,
+    "pooling_kernel_size": 3,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "return_metadata": false,
+    "video_processor_type": "Gemma4VideoProcessor"
+  }
+}

merged_model/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc8d3a0ce36466ccc1278bf987df5f71db1719b9ca6b4118264f45cb627bfe0f
+size 32169626

merged_model/tokenizer_config.json

@@ -0,0 +1,74 @@
+{
+  "audio_token": "<|audio|>",
+  "backend": "tokenizers",
+  "boa_token": "<|audio>",
+  "boi_token": "<|image>",
+  "bos_token": "<bos>",
+  "eoa_token": "<audio|>",
+  "eoc_token": "<channel|>",
+  "eoi_token": "<image|>",
+  "eos_token": "<eos>",
+  "eot_token": "<turn|>",
+  "escape_token": "<|\"|>",
+  "etc_token": "<tool_call|>",
+  "etd_token": "<tool|>",
+  "etr_token": "<tool_response|>",
+  "extra_special_tokens": [
+    "<|video|>"
+  ],
+  "image_token": "<|image|>",
+  "mask_token": "<mask>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<pad>",
+  "padding_side": "left",
+  "processor_class": "Gemma4Processor",
+  "response_schema": {
+    "type": "object",
+    "properties": {
+      "role": {
+        "const": "assistant"
+      },
+      "thinking": {
+        "type": "string"
+      },
+      "content": {
+        "type": "string"
+      },
+      "tool_calls": {
+        "x-regex-iterator": "<\\|tool_call>(.*?)<tool_call\\|>",
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "type": {
+              "const": "function"
+            },
+            "function": {
+              "type": "object",
+              "x-regex": "call\\:(?P<name>\\w+)(?P<arguments>\\{.*\\})",
+              "properties": {
+                "name": {
+                  "type": "string"
+                },
+                "arguments": {
+                  "type": "object",
+                  "x-parser": "gemma4-tool-call",
+                  "additionalProperties": {}
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "x-regex": "(\\<\\|channel\\>thought\\n(?P<thinking>.*?)\\<channel\\|\\>)?(?P<tool_calls>\\<\\|tool_call\\>.*\\<tool_call\\|\\>)?(?P<content>(?:(?!\\<turn\\|\\>)(?!\\<\\|tool_response\\>).)+)?(?:\\<turn\\|\\>|\\<\\|tool_response\\>)?"
+  },
+  "soc_token": "<|channel>",
+  "sot_token": "<|turn>",
+  "stc_token": "<|tool_call>",
+  "std_token": "<|tool>",
+  "str_token": "<|tool_response>",
+  "think_token": "<|think|>",
+  "tokenizer_class": "GemmaTokenizer",
+  "unk_token": "<unk>"
+}

ollama/Modelfile

@@ -0,0 +1,11 @@
+FROM ../merged_model
+TEMPLATE """{{ if .System }}<|im_start|>system
+{{ .System }}<|im_end|>
+{{ end }}{{ if .Prompt }}<|im_start|>user
+{{ .Prompt }}<|im_end|>
+{{ end }}<|im_start|>assistant
+"""
+PARAMETER temperature 0.1
+PARAMETER num_ctx 8192
+PARAMETER stop "<|im_end|>"
+PARAMETER stop "<|endoftext|>"

ollama/create_ollama_model.ps1

@@ -0,0 +1,21 @@
+param(
+    [string]$ModelName = "lumynax-infused-gemma-e4b"
+)
+
+$ErrorActionPreference = "Stop"
+Set-StrictMode -Version Latest
+
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$modelfilePath = Join-Path $scriptDir "Modelfile"
+
+if (-not (Get-Command ollama -ErrorAction SilentlyContinue)) {
+    throw "The `ollama` CLI is not installed. Install Ollama first."
+}
+
+& ollama create $ModelName -f $modelfilePath
+if ($LASTEXITCODE -ne 0) {
+    exit $LASTEXITCODE
+}
+
+Write-Output "Created Ollama model: $ModelName"
+Write-Output "Run it with: ollama run $ModelName"

quickstart.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import torch
+from transformers import AutoModelForMultimodalLM, AutoProcessor
+
+MODEL_TITLE = "LumynaX Infused Gemma E4B Model"
+SUPPORTED_MODALITIES = ('text', 'image', 'audio')
+DEFAULT_ENABLE_THINKING = True
+DEFAULT_SYSTEM_PROMPT = 'You are LumynaX operating from the LumynaX Infused Gemma E4B Model package identity. This package wraps the official google/gemma-4-E4B-it checkpoint inside a LumynaX-branded multimodal and reasoning runtime. Always identify yourself as LumynaX when asked who you are. Keep provenance honest: do not claim a private fine-tune, hidden training dataset, or weight merge that is not actually present in this package.'
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            f"Run a local Gemma E4B quickstart for {MODEL_TITLE}. "
+            f"Supported modalities: text, image, audio."
+        )
+    )
+    parser.add_argument("--mode", choices=["text", "image", "audio"], default="text")
+    parser.add_argument(
+        "--prompt",
+        default="Explain in two short bullet points what this local package is.",
+        help="Text instruction to send to the model.",
+    )
+    parser.add_argument("--image", default="", help="Local image path or image URL for --mode image.")
+    parser.add_argument("--audio", default="", help="Local audio path or audio URL for --mode audio.")
+    parser.add_argument("--max-new-tokens", type=int, default=256)
+    parser.add_argument(
+        "--thinking",
+        action=argparse.BooleanOptionalAction,
+        default=DEFAULT_ENABLE_THINKING,
+        help="Enable Gemma reasoning mode.",
+    )
+    return parser
+
+
+def _message_content(args: argparse.Namespace) -> list[dict[str, str]]:
+    if args.mode == "text":
+        return [{"type": "text", "text": args.prompt}]
+    if args.mode == "image":
+        if not args.image:
+            raise SystemExit("--image is required when --mode image is used.")
+        image_ref = args.image.strip()
+        return [
+            {"type": "image", "url": image_ref},
+            {"type": "text", "text": args.prompt},
+        ]
+    if not args.audio:
+        raise SystemExit("--audio is required when --mode audio is used.")
+    audio_ref = args.audio.strip()
+    return [
+        {"type": "audio", "audio": audio_ref},
+        {"type": "text", "text": args.prompt},
+    ]
+
+
+def main() -> None:
+    args = _build_parser().parse_args()
+    model_dir = Path(__file__).resolve().parent / "merged_model"
+    if not model_dir.exists():
+        raise SystemExit(f"Expected merged_model/ at {model_dir}")
+
+    processor = AutoProcessor.from_pretrained(model_dir)
+    model = AutoModelForMultimodalLM.from_pretrained(
+        model_dir,
+        dtype="auto",
+        device_map="auto",
+    )
+    messages = [
+        {
+            "role": "system",
+            "content": [
+                {
+                    "type": "text",
+                    "text": DEFAULT_SYSTEM_PROMPT,
+                }
+            ],
+        },
+        {
+            "role": "user",
+            "content": _message_content(args),
+        },
+    ]
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        return_dict=True,
+        return_tensors="pt",
+        add_generation_prompt=True,
+        enable_thinking=args.thinking,
+    ).to(model.device)
+    input_len = inputs["input_ids"].shape[-1]
+
+    with torch.inference_mode():
+        outputs = model.generate(**inputs, max_new_tokens=args.max_new_tokens)
+
+    response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
+    parsed = processor.parse_response(response) if hasattr(processor, "parse_response") else response
+    if isinstance(parsed, str):
+        print(parsed)
+        return
+    print(json.dumps(parsed, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

release_export_manifest.json

@@ -0,0 +1,79 @@
+{
+  "artifacts": {
+    "checksums": "checksums.sha256",
+    "gguf": null,
+    "hf_space_app": "hf_space/app.py",
+    "hf_space_dir": "hf_space",
+    "hf_space_readme": "hf_space/README.md",
+    "hf_space_requirements": "hf_space/requirements.txt",
+    "license": "LICENSE.txt",
+    "lumynax_package_identity": "merged_model/LUMYNAX_PACKAGE_IDENTITY.txt",
+    "merged_model": "merged_model",
+    "ollama_create_script": "ollama/create_ollama_model.ps1",
+    "ollama_modelfile": "ollama/Modelfile",
+    "quantized_gguf": null,
+    "quickstart": "quickstart.py",
+    "readme": "README.md",
+    "requirements": "requirements.txt",
+    "training_summary": "artifacts/release_training_summary.json",
+    "version": "VERSION.txt"
+  },
+  "capabilities": {
+    "reasoning_enabled": true,
+    "supported_modalities": [
+      "text",
+      "image",
+      "audio"
+    ]
+  },
+  "delivery": "standalone_hf_base_release",
+  "distribution": {
+    "hf_space": {
+      "app": "hf_space/app.py",
+      "default_model_repo_id": "AbteeXAILab/lumynax-infused-gemma-e4b",
+      "directory": "hf_space",
+      "model_repo_env_var": "LUMYNAX_MODEL_REPO_ID",
+      "readme": "hf_space/README.md",
+      "requirements": "hf_space/requirements.txt",
+      "status": "private_reasoning_multimodal_demo"
+    },
+    "ollama": {
+      "create_script": "ollama/create_ollama_model.ps1",
+      "modelfile": "ollama/Modelfile",
+      "recommended_model_name": "lumynax-infused-gemma-e4b",
+      "status": "not_validated_for_multimodal_base_release"
+    }
+  },
+  "family": null,
+  "generated_at": "2026-04-11T23:33:11.251732+00:00",
+  "lumynax_package_identity": {
+    "chat_template": "merged_model/chat_template.jinja",
+    "hardcoded": true,
+    "identity_file": "merged_model/LUMYNAX_PACKAGE_IDENTITY.txt",
+    "runtime_wrappers": [
+      "quickstart.py",
+      "hf_space/app.py"
+    ]
+  },
+  "manifest_version": 2,
+  "model_title": "LumynaX Infused Gemma E4B Model",
+  "package_state": "base_weights_hydrated",
+  "public_identity": {
+    "model_name": "LumynaX",
+    "organization": "AbteeX AI Labs",
+    "region": "Aotearoa New Zealand"
+  },
+  "release_version": "v1",
+  "runtime": {
+    "delivery_mode": "standalone_base_release",
+    "preferred_backend": "transformers_multimodal",
+    "prompt_format": "huggingface_chat_template",
+    "quickstart_command": "python quickstart.py"
+  },
+  "upstream_model": {
+    "kind": "official_base_weights",
+    "lumynax_weight_adaptation_applied": false,
+    "provider": "Hugging Face",
+    "repo_id": "google/gemma-4-E4B-it"
+  }
+}

requirements.txt

@@ -0,0 +1,9 @@
+accelerate>=1.13
+huggingface-hub>=1.8
+numba>=0.65
+pillow>=10.0
+safetensors>=0.6
+torch>=2.9
+torchvision>=0.24
+transformers>=5.5.3
+librosa>=0.11