jupyter-agent 2025.6.100__py3-none-any.whl → 2025.6.101__py3-none-any.whl

jupyter_agent/bot_outputs.py

@@ -0,0 +1,480 @@
+"""
+Copyright (c) 2025 viewstar000
+
+This software is released under the MIT License.
+https://opensource.org/licenses/MIT
+"""
+
+import json
+import time
+import datetime
+import jinja2
+
+from enum import Enum
+from IPython.display import display, Markdown
+from .utils import no_indent, no_wrap
+
+STAGE_SWITCHER_SCRIPT = no_wrap(
+    """
+this.parentElement.parentElement.querySelectorAll('.agent-stage-title').forEach(function(item) {
+    item.classList.remove('active');
+});
+this.parentElement.parentElement.querySelectorAll('.agent-stage-output-panel').forEach(function(item) {
+    item.classList.remove('active');
+});
+this.parentElement.parentElement.querySelectorAll('.agent-stage-{{ stage }}').forEach(function(item) {
+    item.classList.add('active');
+});
+"""
+)
+
+
+AGENT_OUTPUT_TEMPLEATE = no_indent(
+    """
+<style>
+.agent-output-panel * {
+    box-sizing: border-box;
+}
+
+.agent-output-panel {
+    background-color: rgba(128,128,128,0.1);
+    border-radius: 0.5rem; 
+}
+
+.agent-output-title {
+    cursor: pointer;
+    font-style: italic;
+    color: #888888;
+    padding: 0.5rem;
+}
+
+.agent-output-content {
+    width: unset;
+    padding: 0.5rem;
+    padding-top: 0;
+}
+
+.agent-output-title.collapsed + .agent-output-content {
+    display: none;
+}
+
+.agent-stage-switcher {
+    background-color: rgba(128,128,128,0.1);
+    border-bottom: 2px solid rgba(128,128,128,0.3);
+    padding: 0.5rem 0;
+}
+
+.agent-stage-title {
+    cursor: pointer;
+    font-style: italic;
+    color: #888888;
+    padding: 0.5rem;
+}
+
+.agent-stage-title.active {
+    background-color: rgba(128,128,128,0.3);
+}
+
+.agent-stage-output-panel {
+    display: none;
+}
+
+.agent-stage-output-panel.active {
+    display: block;
+    margin-top: 0.5rem;
+    overflow: auto;
+}
+
+.agent-output-block {
+    background-color: rgba(128,128,128,0.2);
+    border-radius: 0.5rem;
+    margin-top: 0.5rem;
+    margin-bottom: 0.5rem;
+}
+
+.agent-output-block-title {
+    cursor: pointer;
+    font-style: italic;
+    color: #888888;
+    padding: 0.5rem;
+}
+
+.agent-output-block-content {
+    width: unset;
+    padding: 0.5rem;
+}
+
+.agent-output-block-title.collapsed + .agent-output-block-content {
+    display: none;
+}
+</style>
+
+<div class="agent-output-panel">
+    <div class="agent-output-title {{ 'collapsed' if collapsed else ''}}" onclick="this.classList.toggle('collapsed')">
+        {{ title if title else 'Agent Output' }} - {{ active_stage }}
+    </div>
+    <div class="agent-output-content">
+        <div class="agent-stage-switcher">
+            {% for stage in contents.keys() %}
+            <span class="agent-stage-title agent-stage-{{ stage }} {{ 'active' if stage == active_stage }}" onclick="{% include 'switcher_script' %}">
+                {{ stage }}
+            </span>
+            {% endfor %}
+        </div>
+        {% for stage, contents in contents.items() %}
+        <div class="agent-stage-output-panel agent-stage-{{ stage }} {{ 'active' if stage == active_stage }}">
+            {% if stage == 'Logging' +%}
+                ```log
+                {% for content in contents %}
+                    {{ content['content'] }}
+                {% endfor %}
+                ```
+            {% else %}
+                {% for content in contents %}
+                    {% if content['type'] == 'block' %}
+                    <div class="agent-output-block">
+                        <div class="agent-output-block-title {{ 'collapsed' if content['collapsed'] else ''}}" onclick="this.classList.toggle('collapsed')">
+                            {{ content['title'] }}
+                        </div>
+                        <div class="agent-output-block-content">
+                            {% if content['format'] == 'markdown' %}
+                                {{ content['content'] }}
+                            {% elif content['format'] == 'code' +%}
+                                ```{{ content['code_language'] }}
+                                {{ content['content'] }}
+                                ```
+                            {% endif %}
+                        </div>
+                    </div>
+                    {% elif content['type'] == 'markdown' +%}
+                        {{ content['content'] }}
+                    {% elif content['type'] == 'text' +%}
+                        ```{{ content['code_language'] }}
+                        {{ content['content'] }}
+                        ```
+                    {%+ endif %}
+                {% endfor %}
+            {% endif %}
+        </div>
+        {% endfor %}
+    </div>
+</div>
+"""
+)
+
+LOGGING_LEVELS = {
+    "DEBUG": 10,
+    "INFO": 20,
+    "WARN": 30,
+    "ERROR": 40,
+    "FATAL": 50,
+}
+
+
+class AgentOutput:
+    """
+    AgentOutput 是一个用于在 Jupyter Notebook 中显示 Agent 输出的类。
+    """
+
+    def __init__(self, title=None, collapsed=False, logging_level="INFO"):
+        self.title = title
+        self.collapsed = collapsed
+        self.logging_level = (
+            logging_level if isinstance(logging_level, int) else LOGGING_LEVELS.get(logging_level.upper(), 20)
+        )
+        self.jinja_env = jinja2.Environment(
+            trim_blocks=True, lstrip_blocks=True, loader=jinja2.DictLoader({"switcher_script": STAGE_SWITCHER_SCRIPT})
+        )
+        self.template = self.jinja_env.from_string(AGENT_OUTPUT_TEMPLEATE)
+        self.handler = None
+        self._latest_display_tm = 0
+        self._contents = {}
+        self._active_stage = None
+        self._agent_data_timestamp = None
+        self._agent_data = {}
+        self._logging_records = []
+
+    @property
+    def content(self):
+        contents = dict(self._contents)
+        if self._agent_data:
+            contents["Metadata"] = [
+                {
+                    "type": "text",
+                    "content": json.dumps(self.metadata, indent=2, ensure_ascii=False),
+                    "code_language": "json",
+                }
+            ]
+        filtered_logs = [log for log in self._logging_records if log["level"] >= self.logging_level]
+        if len(filtered_logs) > 0:
+            contents["Logging"] = filtered_logs
+        return self.template.render(
+            title=self.title,
+            collapsed=self.collapsed,
+            active_stage=self._active_stage,
+            contents=contents,
+        )
+
+    @property
+    def metadata(self):
+        metadata = {"reply_type": "AgentOutput", "exclude_from_context": True}
+        if self._agent_data:
+            metadata.update(
+                {
+                    "jupyter-agent-data-store": True,
+                    "jupyter-agent-data-timestamp": self._agent_data_timestamp,
+                    "jupyter-agent-data": self._agent_data,
+                }
+            )
+        return metadata
+
+    def display(self, stage=None, force=False, wait=True):
+        if stage is not None:
+            self._active_stage = stage
+        if not force and time.time() - self._latest_display_tm < 1:
+            if wait:
+                time.sleep(1 - (time.time() - self._latest_display_tm))
+            else:
+                return
+        if self.handler is None:
+            self.handler = display(Markdown(self.content), metadata=self.metadata, display_id=True)
+        else:
+            self.handler.update(Markdown(self.content), metadata=self.metadata)
+        self._latest_display_tm = time.time()
+
+    def clear(self, stage=None, clear_metadata=False):
+        if stage is None:
+            self._contents = {}
+        else:
+            self._contents[stage] = []
+        if clear_metadata:
+            self._agent_data = {}
+        self.display(force=False, wait=False)
+
+    def output_block(
+        self, content, title="Block", collapsed=True, stage=None, format="markdown", code_language="python"
+    ):
+        if stage is None:
+            stage = self._active_stage
+        if stage not in self._contents:
+            self._contents[stage] = []
+        self._contents[stage].append(
+            {
+                "type": "block",
+                "title": title,
+                "content": content,
+                "collapsed": collapsed,
+                "format": format,
+                "code_language": code_language,
+            }
+        )
+        self.display(stage, force=False, wait=False)
+
+    def output_text(self, content, stage=None, code_language="python"):
+        if stage is None:
+            stage = self._active_stage
+        if stage not in self._contents:
+            self._contents[stage] = []
+        if (
+            len(self._contents[stage]) > 0
+            and self._contents[stage][-1]["type"] == "text"
+            and self._contents[stage][-1]["code_language"] == code_language
+        ):
+            self._contents[stage][-1]["content"] += "\n" + content
+        else:
+            self._contents[stage].append({"type": "text", "content": content, "code_language": code_language})
+        self.display(stage, force=False, wait=False)
+
+    def output_markdown(self, content, stage=None):
+        if stage is None:
+            stage = self._active_stage
+        if stage not in self._contents:
+            self._contents[stage] = []
+        self._contents[stage].append({"type": "markdown", "content": content})
+        self.display(stage, force=False, wait=False)
+
+    def output_agent_data(self, **kwargs):
+        self.log(f"output agent data {kwargs}", level="DEBUG")
+        self._agent_data.update(kwargs)
+        self._agent_data_timestamp = int(time.time() * 1000)
+        self.display(force=False, wait=False)
+
+    def log(self, msg, level="INFO"):
+        level = level.upper()
+        assert level in LOGGING_LEVELS
+        tm = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
+        level_n = LOGGING_LEVELS[level]
+        content = f"[{tm}] {level}: {msg}"
+        if self._logging_records and self._logging_records[-1]["level"] == level_n:
+            self._logging_records[-1]["content"] += "\n" + content
+        else:
+            self._logging_records.append(
+                {
+                    "type": "logging",
+                    "level": level_n,
+                    "level_name": level,
+                    "time": tm,
+                    "msg": msg,
+                    "content": content,
+                }
+            )
+        self.display(force=False, wait=False)
+
+
+__agent_output = None
+
+
+def get_output():
+    global __agent_output
+    if __agent_output is None:
+        __agent_output = AgentOutput()
+    return __agent_output
+
+
+def set_stage(stage):
+    get_output().display(stage)
+
+
+def reset_output(title=None, collapsed=False, stage=None, logging_level="INFO"):
+    global __agent_output
+    __agent_output = AgentOutput(title, collapsed, logging_level)
+    if stage is not None:
+        __agent_output.display(stage)
+    return __agent_output
+
+
+def log(msg, level="INFO"):
+    get_output().log(msg, level)
+
+
+def output_block(content, title="Block", collapsed=True, stage=None, format="markdown", code_language="python"):
+    get_output().output_block(content, title, collapsed, stage, format, code_language)
+
+
+def output_text(content, stage=None, code_language="python"):
+    get_output().output_text(content, stage, code_language)
+
+
+def output_markdown(content, stage=None):
+    get_output().output_markdown(content, stage)
+
+
+def output_agent_data(**kwargs):
+    get_output().output_agent_data(**kwargs)
+
+
+def clear_output(stage=None, clear_metadata=False):
+    get_output().clear(stage, clear_metadata)
+
+
+def flush_output(force=False):
+    get_output().display(force=force, wait=True)
+
+
+def set_title(title):
+    get_output().title = title
+
+
+def set_collapsed(collapsed):
+    get_output().collapsed = collapsed
+
+
+def set_logging_level(logging_level):
+    if isinstance(logging_level, int):
+        get_output().logging_level = logging_level
+    else:
+        logging_level = logging_level.upper()
+        assert logging_level in LOGGING_LEVELS
+        get_output().logging_level = LOGGING_LEVELS[logging_level]
+
+
+class ReplyType(str, Enum):
+    CELL_CODE = "cell_code"
+    CELL_OUTPUT = "cell_output"
+    CELL_RESULT = "cell_result"
+    CELL_ERROR = "cell_error"
+    TASK_PROMPT = "task_prompt"
+    TASK_RESULT = "task_result"
+    TASK_ISSUE = "task_issue"
+    DEBUG = "debug"
+    THINK = "think"
+    CODE = "code"
+    FENCE = "fence"
+    TEXT = "text"
+
+
+def agent_display(obj, reply_type=None, exclude_from_context=False, **kwargs):
+    """自定义的 display 函数，用于在 Jupyter 中显示对象"""
+    assert "metadata" not in kwargs
+    metadata = {"reply_type": reply_type, "exclude_from_context": exclude_from_context}
+    metadata.update(kwargs)
+    return display(obj, metadata=metadata)
+
+
+_block_style = """
+<style>
+.block-panel * {
+    box-sizing: border-box;
+}
+
+.block-panel {
+    background-color: rgba(128,128,128,0.2);
+    border-radius: 0.5rem;
+    box-sizing: border-box;
+}
+
+.block-title {
+    cursor: pointer;
+    font-style: italic;
+    color: #888888;
+    padding: 0.5rem;
+}
+
+.block-content {
+    width: unset;
+    padding: 0.5rem;
+}
+
+.block-title.collapsed + .block-content {
+    display: none;
+}
+</style>
+"""
+
+
+def markdown_block(block, title="Block", collapsed=True):
+
+    default_state = "collapsed" if collapsed else ""
+
+    return Markdown(
+        _block_style
+        + '<div class="block-panel" >'
+        + f'<div class="block-title {default_state}" onclick="this.classList.toggle(\'collapsed\')">'
+        + f"{title} (click to expand)"
+        + "</div>"
+        + '<div class="block-content" >\n\n'
+        + block
+        + "\n\n</div>"
+        + "</div>"
+    )
+
+
+_O = lambda obj, reply_type=None, **kwargs: agent_display(
+    obj, reply_type=reply_type, exclude_from_context=True, **kwargs
+)
+
+
+_C = lambda obj, reply_from=None, reply_type=None, **kwargs: agent_display(
+    obj, reply_type=reply_type, exclude_from_context=False, **kwargs
+)
+
+_M = output_markdown
+_T = output_text
+_B = output_block
+_A = output_agent_data
+_L = log
+_D = lambda msg: log(msg, level="DEBUG")
+_I = lambda msg: log(msg, level="INFO")
+_W = lambda msg: log(msg, level="WARNING")
+_E = lambda msg: log(msg, level="ERROR")
+_F = lambda msg: log(msg, level="FATAL")

jupyter_agent/utils.py

@@ -0,0 +1,138 @@
+"""
+Copyright (c) 2025 viewstar000
+
+This software is released under the MIT License.
+https://opensource.org/licenses/MIT
+"""
+
+import io
+import os
+import re
+import sys
+import json
+import jinja2
+import openai
+
+from enum import Enum
+from typing import Optional
+from pydantic import BaseModel, Field
+from IPython.display import display as ipython_display, Markdown
+from IPython.core.getipython import get_ipython
+from IPython.core.displaypub import CapturingDisplayPublisher
+from IPython.core.displayhook import CapturingDisplayHook
+from IPython.utils.capture import capture_output, CapturedIO
+from IPython.utils.io import Tee
+
+
+class CloselessStringIO(io.StringIO):
+    def close(self):
+        pass
+
+    def __del__(self):
+        super().close()
+        return super().__del__()
+
+
+class TeeCapturingDisplayPublisher(CapturingDisplayPublisher):
+
+    def __init__(self, *args, original_display_pub=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        ipy = get_ipython()
+        self.original_display_pub = original_display_pub or (ipy.display_pub if ipy is not None else None)
+
+    def publish(self, *args, **kwargs):
+        super().publish(*args, **kwargs)
+        if self.original_display_pub is not None:
+            self.original_display_pub.publish(*args, **kwargs)
+
+
+class TeeCapturingDisplayHook(CapturingDisplayHook):
+
+    def __init__(self, *args, original_display_hook=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.original_display_hook = original_display_hook or sys.displayhook
+
+    def __call__(self, *args, **kwargs):
+        super().__call__(*args, **kwargs)
+        self.original_display_hook(*args, **kwargs)
+
+
+class TeeOutputCapture(capture_output):
+
+    def __enter__(self):
+
+        self.sys_stdout = sys.stdout
+        self.sys_stderr = sys.stderr
+
+        if self.display:
+            self.shell = get_ipython()
+            if self.shell is None:
+                self.save_display_pub = None
+                self.display = False
+
+        stdout = stderr = outputs = None
+        if self.stdout:
+            stdout = CloselessStringIO()
+            sys.stdout = Tee(stdout, channel="stdout")
+        if self.stderr:
+            stderr = CloselessStringIO()
+            sys.stderr = Tee(stderr, channel="stderr")
+        if self.display:
+            if self.shell is not None:
+                self.save_display_pub = self.shell.display_pub
+                self.shell.display_pub = TeeCapturingDisplayPublisher()
+                outputs = self.shell.display_pub.outputs
+                self.save_display_hook = sys.displayhook
+                sys.displayhook = TeeCapturingDisplayHook(shell=self.shell, outputs=outputs)
+            else:
+                self.save_display_pub = None
+                outputs = None
+
+        return CapturedIO(stdout, stderr, outputs)
+
+
+class RequestUserPrompt(BaseModel):
+    prompt: str = Field(
+        description="需要用户补充详细信息的Prompt",
+        examples=["请补充与...相关的详细的信息", "请确认...是否...", "请提供..."],
+    )
+    example: Optional[str] = Field(None, description="示例", examples=["..."])
+
+
+class UserPromptResponse(BaseModel):
+    prompt: str = Field(description="需要用户补充详细信息的Prompt", examples=["..."])
+    response: str = Field(description="用户补充的详细信息", examples=["..."])
+
+
+def request_user_response(prompts: list[RequestUserPrompt]) -> list[UserPromptResponse]:
+    responses = []
+    for prompt in prompts:
+        response = input(f"{prompt.prompt} (例如: {prompt.example})")
+        responses.append(UserPromptResponse(prompt=prompt.prompt, response=response))
+    return responses
+
+
+def format_user_prompts(prompts: list[RequestUserPrompt], title="用户补充详细信息") -> str:
+    result = "```markdown\n"
+    result += f"### {title}\n\n"
+    result += "\n".join(
+        [f"- **Issue**: {prompt.prompt} (例如: {prompt.example})\n- **Reply**: " for prompt in prompts]
+    )
+    result += "\n```\n"
+    return result
+
+
+def no_indent(text: str) -> str:
+    return re.sub(r"^\s+", "", text, flags=re.MULTILINE)
+
+
+def no_wrap(text: str) -> str:
+    return re.sub(r"\s+", " ", text, flags=re.MULTILINE)
+
+
+def no_newline(text: str) -> str:
+    return re.sub(r"\n+", " ", text, flags=re.MULTILINE)
+
+
+def no_space(text: str) -> str:
+    return re.sub(r"\s+", "", text, flags=re.MULTILINE)

{jupyter_agent-2025.6.100.dist-info → jupyter_agent-2025.6.101.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jupyter-agent
-Version: 2025.6.100
+Version: 2025.6.101
 Summary: 调用LLM实现Jupyter代码的自动生成、执行、调试等功能
 Author: viewstar000
 License: MIT
@@ -29,7 +29,16 @@ Dynamic: license-file
 - 提供`%%bot`指令，在juyter环境中，通过调用LLM实现代码生成、执行、调试等能力
 - 支持调用OpenAI兼容API，实现LLM相关的功能
 
-## 打包（Build）
+## 安装
+
+```bash
+# 激活目标环境(视情况选择)
+source /path/to/target_env/bin/activate
+
+pip install jupyter-agent
+```
+
+## 源码打包安全（Build）
 
 ```bash
 # 下载代码
@@ -46,15 +55,12 @@ python -m build
 
 # 退出打包环境
 deactivate
-```
-
-## 安装
 
-```bash
 # 激活目标环境
 source /path/to/target_env/bin/activate
+
 # 安装编译好的wheel包
-pip install /path/to/upyter-agent/dist/jupyter_agent-202506.1-py3-none-any.whl
+pip install /path/to/upyter-agent/dist/jupyter_agent-xxxx-py3-none-any.whl
 ```
 
 ## 使用方法

jupyter_agent-2025.6.101.dist-info/RECORD

@@ -0,0 +1,33 @@
+jupyter_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jupyter_agent/bot_chat.py,sha256=RkaT-Cpkp3G24F1AtbcgqjKo-LBxwMNAYHVitaPZNOg,8834
+jupyter_agent/bot_contexts.py,sha256=eFezr7ImokMz33jJJMlLLQspQBYnuE6Bc2bE1wLbXWU,19123
+jupyter_agent/bot_magics.py,sha256=PQib9GoefCAkh2Hy1InfdoiFo-KE-9wJ4qKEj_k9zO4,6570
+jupyter_agent/bot_outputs.py,sha256=7_cbOBaGdoYMR6qu43nZEsB9KY6wp4zA0Dh7Jq7LMTg,14065
+jupyter_agent/utils.py,sha256=jbvDtVK6MfGaf5ZLoam_sq9R5TMriEG4HbMF0bHHDes,4387
+jupyter_agent/bot_agents/__init__.py,sha256=IdlBlvfaDUfp3qhkNuwUVV_CdplafZsgLezLVkZCREw,1323
+jupyter_agent/bot_agents/base.py,sha256=50XtKBVRj83zALGgw4klGLZkUlqHNhs1WIX5av9bIm4,10893
+jupyter_agent/bot_agents/master_planner.py,sha256=nIY3F4ALtEU8QOO6dqe7pI5V-o_pwdM2MllH-n2Jb-Y,1289
+jupyter_agent/bot_agents/output_task_result.py,sha256=p_fq4zKUMZIz5W7y2Bvq0uhjwgHUn_MIt9Qr24nFR58,837
+jupyter_agent/bot_agents/task_code_executor.py,sha256=M3oeEBlmsNz89f-yk3_nzsWKGH2C0o7AH059D_J94D8,2206
+jupyter_agent/bot_agents/task_coder.py,sha256=7fXq9nk1yH3F_mJfCMZBktHmxGfgmpuChMQbpEuL0w4,1783
+jupyter_agent/bot_agents/task_debuger.py,sha256=77pa_Awgvzxm3XkFA1oZsGr8SPJkjApKMtkmoySShmI,1367
+jupyter_agent/bot_agents/task_planner_v1.py,sha256=3teMKJz82Jtms0ERLGCCRoui-gzmTDpi8So6ZjR5z3w,5990
+jupyter_agent/bot_agents/task_planner_v2.py,sha256=BYFDRC8q9AT00iL4l54GZWhgjs_m5R0F_vOVmmGEiLA,7632
+jupyter_agent/bot_agents/task_planner_v3.py,sha256=KP6qj7lLUeebPZwypmK_oKYa-84RpkCrJVJk7yJkTJw,8545
+jupyter_agent/bot_agents/task_reasoner.py,sha256=Am7ZNZNnn6aMm4UMCDLdb3CA73nNvydx8bmGXJAsJ2k,1469
+jupyter_agent/bot_agents/task_structrue_reasoner.py,sha256=KRs_dRwsBisMT5A5SqzSi4rbRnj6wpapABtlOKVFvSk,3733
+jupyter_agent/bot_agents/task_structrue_summarier.py,sha256=jirpFP2UmhJxbrkOWx45AOZnSXbhim_XfZmVU-RzcNk,4087
+jupyter_agent/bot_agents/task_summarier.py,sha256=bvYEKW_NWRwe-kNNxR7uhJTMKMJXSyfnGgOpxCoBleU,1791
+jupyter_agent/bot_agents/task_verifier.py,sha256=9Tlyb7hP7tBHMrh5XkRD30mYLodNum33X6v2snjm0QI,2478
+jupyter_agent/bot_agents/task_verify_summarier.py,sha256=mhpqgcBPOur0TtG8rYUT-BCAYgAiJxDgXVnCAE5Cucs,4963
+jupyter_agent/bot_flows/__init__.py,sha256=vbb3GJLu6aZdJ2ox4eaHn5cg0d4WQM6zmhIbMAlHIFo,488
+jupyter_agent/bot_flows/base.py,sha256=o94y9H8E9FCGz7srdyJDl7UcAj7RCEJCBjtSSREvcWY,8437
+jupyter_agent/bot_flows/master_planner.py,sha256=2MvAMikMsBIarTL4QNYTjAs70bxo7VAV0DbHus325Es,430
+jupyter_agent/bot_flows/task_executor_v1.py,sha256=WzTfoOTjBpk1emvpiL3yeiudKdDf6EpVdJIugxxbqM4,2975
+jupyter_agent/bot_flows/task_executor_v2.py,sha256=IyfxhzA4TljNd6iqqUYxxzB63r9lxfe1Zbu177hytRs,2949
+jupyter_agent/bot_flows/task_executor_v3.py,sha256=NwJy7iAo2U3rl5iQYpACWVAkIA5DRMDdx0JadheRMMQ,3198
+jupyter_agent-2025.6.101.dist-info/licenses/LICENSE,sha256=nWMmSIg7OepTIDX_OPP0-T9ImeCBBoog7eJxm5awtcM,1068
+jupyter_agent-2025.6.101.dist-info/METADATA,sha256=NYsa293tWtXEWVKS_SUzIq0cxHiSbUOUzXRrmCpILkU,3815
+jupyter_agent-2025.6.101.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jupyter_agent-2025.6.101.dist-info/top_level.txt,sha256=c3USTBZ7DZGuvLKlEW-QfGIx0tzn98iCEn3bpdYnDtE,14
+jupyter_agent-2025.6.101.dist-info/RECORD,,

jupyter_agent-2025.6.101.dist-info/top_level.txt

@@ -0,0 +1 @@
+jupyter_agent

jupyter_agent-2025.6.100.dist-info/RECORD

@@ -1,5 +0,0 @@
-jupyter_agent-2025.6.100.dist-info/licenses/LICENSE,sha256=nWMmSIg7OepTIDX_OPP0-T9ImeCBBoog7eJxm5awtcM,1068
-jupyter_agent-2025.6.100.dist-info/METADATA,sha256=39YUZaaG0ZJY0gZHzX64jOMuTRk434KAn3zIhsYGoN8,3700
-jupyter_agent-2025.6.100.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jupyter_agent-2025.6.100.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-jupyter_agent-2025.6.100.dist-info/RECORD,,