@@ -96,12 +96,14 @@ the syntax does not make obvious.
     extra thought.
 *   **`{artifact.filename}` loads a file instead of a state value.** The engine
     asks the artifact service for that artifact in the current session and
-    substitutes `str()` of what comes back. A missing artifact raises
+    converts a `types.Part` with `load_artifacts_tool.as_safe_part_for_llm`:
+    `Part.text` and text-like `inline_data` (`text/*`, JSON, XML, CSV, or DOCX)
+    are substituted as their text content, other binary blobs render as a
+    `[Binary artifact: ...]` placeholder, and Gemini-native inline media (such
+    as `image/*` or `application/pdf`) falls back to `str()`, which is the
+    Pydantic field dump rather than prompt text. A missing artifact raises
     `KeyError`, and `{artifact.filename?}` substitutes an empty string in the
-    same way the optional state form does. Check what that `str()` produces
-    before relying on the form: an artifact fetched from an artifact service is
-    a `types.Part`, and its `str()` is the whole Pydantic field dump rather than
-    the text you had in mind.
+    same way the optional state form does.
 
 A state key may carry one of the state prefixes, so `{app:theme}`,
 `{user:locale}`, and `{temp:draft}` all work, and read from the corresponding
@@ -266,16 +268,17 @@ function to instructions. Anywhere you hold a `ReadonlyContext`, and a
     missing, so it raises. `{customer name}` is not a valid name, so it is left
     in the prompt untouched and the model sees the braces. The two typos fail in
     completely different ways.
-*   **Artifacts are stringified, and that is almost never what you want.** Both
-    engines insert `str(artifact)`, and an artifact loaded from an artifact
-    service is a `types.Part`, whose `str()` is the Pydantic field dump. A
-    plain-text artifact reading "hello world" reaches the prompt as
-    `media_resolution=None code_execution_result=None ... text='hello world'
-    thought=None ...`, which is every field of the Part when only one of them
-    was what you wanted. Binary data is worse still. There is no option to
-    extract `.text`, so an
-    instruction that needs an artifact's contents should load it in Python and
-    interpolate the text itself rather than using `{artifact.name}`.
+*   **Binary and media artifacts cannot be inlined into an instruction.** Both
+    engines pass a loaded `types.Part` through
+    `load_artifacts_tool.as_safe_part_for_llm`, because an instruction is a
+    plain string: `Part.text` and text-like `inline_data` (`text/*`, JSON, XML,
+    CSV, or DOCX) unwrap to their text, other binary blobs render as a
+    `[Binary artifact: name, type, size]` placeholder, and Gemini-native media
+    (`image/*`, `audio/*`, `video/*`, `application/pdf`) or a `file_data`
+    reference has no `.text` and falls back to `str(artifact)`, which inserts
+    the Pydantic field dump into the prompt. Use `{artifact.name}` and
+    `artifact('name')` only for text artifacts, and pass binary or media
+    artifacts to the model as content parts instead.
 *   **A callable instruction gets no injection.** The omission is deliberate,
     on the assumption that a function with access to the context can interpolate
     for itself, and it is the reason to call this function yourself.
 
@@ -22,10 +22,12 @@
 from typing import Callable
 from typing import Union
 
+from google.genai import types
 from typing_extensions import TypeAlias
 
 from ....agents.readonly_context import ReadonlyContext
 from ....sessions.state import State
+from ....tools import load_artifacts_tool
 
 __all__ = [
     'InstructionProvider',
@@ -43,6 +45,15 @@
 _TEMPLATE_VAR_PATTERN = re.compile(r'(?<![\$\{\\]){+[^{}]*}+')
 
 
+def _artifact_to_text(artifact: object, artifact_name: str) -> str:
+  """Renders a loaded artifact as instruction text."""
+  if isinstance(artifact, types.Part):
+    safe = load_artifacts_tool.as_safe_part_for_llm(artifact, artifact_name)
+    if safe.text is not None:
+      return safe.text
+  return str(artifact)
+
+
 async def inject_session_state(
     template: str,
     readonly_context: ReadonlyContext,
@@ -164,7 +175,7 @@ async def _replace_match(match: re.Match[str]) -> str:
               f"Artifact '{var_name}' not found in agent"
               f" '{readonly_context.agent_name}'."
           )
-      return str(artifact)
+      return _artifact_to_text(artifact, var_name)
     else:
       if not _is_valid_state_name(var_name):
         return str(match.group())
@@ -238,7 +249,7 @@ async def _load_artifact(filename: str) -> str:
           f"Artifact '{filename}' not found in agent"
           f" '{readonly_context.agent_name}'."
       )
-    return str(artifact)
+    return _artifact_to_text(artifact, filename)
 
   env = SandboxedEnvironment(
       enable_async=True,
 
@@ -19,10 +19,12 @@
 from google.adk.agents.llm_agent import Agent
 from google.adk.agents.llm_agent import InstructionProvider as LlmAgentInstructionProvider
 from google.adk.agents.readonly_context import ReadonlyContext
+from google.adk.artifacts import InMemoryArtifactService
 from google.adk.flows.llm_flows.prompt import _instructions_utils as instructions_utils
 from google.adk.flows.llm_flows.prompt._instructions_utils import _is_valid_state_name
 from google.adk.flows.llm_flows.prompt._instructions_utils import InstructionProvider
 from google.adk.sessions.session import Session
+from google.genai import types
 import pytest
 
 from .... import testing_utils
@@ -566,3 +568,55 @@ async def test_inject_session_state_jinja2_state_mapping_is_read_only():
         use_jinja2=True,
     )
   assert invocation_context.session.state == {"user:name": "Foo", "count": 1}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "use_jinja2,template",
+    [
+        (False, "Notes: {artifact.notes}"),
+        (True, "Notes: {{ artifact('notes') }}"),
+    ],
+    ids=["regex", "jinja2"],
+)
+@pytest.mark.parametrize(
+    "artifact,expected",
+    [
+        (types.Part(text="Buy milk."), "Notes: Buy milk."),
+        (
+            types.Part.from_bytes(data=b"Buy milk.", mime_type="text/plain"),
+            "Notes: Buy milk.",
+        ),
+        (
+            types.Part.from_bytes(
+                data=b"\x00\x01\x02\x03", mime_type="application/octet-stream"
+            ),
+            (
+                "Notes: [Binary artifact: notes, type:"
+                " application/octet-stream, size: 0.0 KB. Content cannot be"
+                " displayed inline.]"
+            ),
+        ),
+    ],
+    ids=["text_part", "text_inline_data", "binary_inline_data"],
+)
+async def test_inject_session_state_artifact_part_renders_as_text(
+    use_jinja2, template, artifact, expected
+):
+  artifact_service = InMemoryArtifactService()
+  await artifact_service.save_artifact(
+      app_name="test_app",
+      user_id="test_user",
+      session_id="test_session_id",
+      filename="notes",
+      artifact=artifact,
+  )
+  invocation_context = await _create_test_readonly_context(
+      artifact_service=artifact_service
+  )
+
+  populated_instruction = await instructions_utils.inject_session_state(
+      template, invocation_context, use_jinja2=use_jinja2
+  )
+
+  assert populated_instruction == expected