diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index 29a28d9..bd5e927 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -14,6 +14,12 @@ instructions: - Run formatters and linters (make format / make lint). - Update documentation where applicable. + - ALWAYS verify the code after finishing running `make format lint`: + * Run tests to confirm formatting/linting changes don't break functionality + * Check for any remaining code issues or warnings + * Ensure all files have been processed correctly + * Report the verification results to the user + - If the suggestion touches public APIs or behavior, encourage adding typed signatures and small unit tests. diff --git a/AGENT_BUILD_REFERENCE.md b/AGENT_BUILD_REFERENCE.md new file mode 100644 index 0000000..4aa4839 --- /dev/null +++ b/AGENT_BUILD_REFERENCE.md @@ -0,0 +1,235 @@ +# Agent Build Reference (assistant_core) + +## Audience + +This document is a prescriptive reference for AI agents (and developers) building projects that import assistant_core as an external library. + +## Goal + +Build a compiled LangGraph assistant that: +- uses assistant_core builder/context abstractions, +- supports tool calling, +- can be invoked with a thread id, +- and is easy to extend with custom builders. + +## Hard Rules + +1. Prefer `ContextFactory` and `BuilderContext.create(...)` for new code. +2. Do not introduce new implementations based on `BaseAgentFactory` (deprecated). +3. Use `SingleAgent` unless there is a real routing need for `MultiAgent`. +4. Keep custom builders small and side-effect only through `context`. +5. Group related tools in a single domain builder and register them together. +6. Do not pass tool objects as builder constructor parameters; builders should define the related tool set internally. + +## Build From Scratch (Single Agent) + +### 1) Install and import dependencies + +```bash +# Install assistant_core from GitHub (project is not on PyPI yet). +# Choose one command based on your package manager. + +# pip +pip install "git+https://github.com/LOBICA/assistant_core.git" + +# uv +uv add "git+https://github.com/LOBICA/assistant_core.git" + +# Poetry +poetry add "git+https://github.com/LOBICA/assistant_core.git" + +# PDM +pdm add "git+https://github.com/LOBICA/assistant_core.git" +``` + +```python +from langgraph.checkpoint.memory import MemorySaver + +from assistant_core.builder import BuilderContext, SingleAgent +from assistant_core.nodes import AgentNode +``` + +### 2) Define agent behavior + +Create an `agent_factory(model)` that returns an `AgentNode`. + +```python +SYSTEM_PROMPT = """ +You are a concise and reliable assistant. +Use available tools when needed. +""".strip() + + +def agent_factory(model): + return AgentNode( + name="assistant", + model=model, + prompts=[SYSTEM_PROMPT], + ) +``` + +### 3) Create context + +Use `BuilderContext.create(...)` and pass config with `OPENAI_API_KEY` when using the default model path. + +```python +def build_context(openai_api_key: str) -> BuilderContext: + return BuilderContext.create( + { + "OPENAI_API_KEY": openai_api_key, + }, + agent_factory=agent_factory, + ) +``` + +### 4) Compose graph + +Use `SingleAgent` and register optional builders before `make(...)`. + +```python +def build_graph(openai_api_key: str): + context = build_context(openai_api_key) + + director = SingleAgent() + # Example: director.add_builder(MyCustomBuilder(...)) + + workflow = director.make(context) + return workflow.compile(checkpointer=MemorySaver()) +``` + +### 5) Invoke graph + +Always pass a stable `thread_id` in config. + +```python +async def run_once(graph): + config = {"configurable": {"thread_id": "my-thread-1"}} + result = await graph.ainvoke( + { + "messages": [ + { + "role": "user", + "content": "Hello", + } + ] + }, + config=config, + ) + return result["messages"][-1] +``` + +## Add Tools + +Tools are registered through builders by appending to `context.tools`. + +Preferred pattern: one builder owns a related set of tools for a domain capability. + +```python +from assistant_core.builder import BaseBuilder + + +class CustomerSupportToolsBuilder(BaseBuilder): + """Register customer-support related tools as one cohesive capability set.""" + + def build(self, context): + context.tools.append(get_customer_profile) + context.tools.append(get_open_tickets) + context.tools.append(create_ticket) + context.tools.append(update_ticket) +``` + +```python +director = SingleAgent() +director.add_builder(DateTimeBuilder()) +director.add_builder(CustomerSupportToolsBuilder()) +``` + +When `SingleAgent.make(...)` runs: +- tools are rebound to the `AgentNode`, +- a `ToolNode` is wired, +- control returns through `ResolverNode`. + +## Add Pre-Agent Steps + +To add preprocessing or context-injection steps, create builders that: +1. add one or more nodes, +2. set `context.entrypoint`. + +Entrypoints are chained in LIFO order. + +```python +from assistant_core.builder import BaseBuilder +from assistant_core.nodes import PromptNode + + +class IntakePromptBuilder(BaseBuilder): + def build(self, context): + node = PromptNode( + name="intake_prompt", + prompt="You are handling a support request.", + ) + context.graph_builder.add_node(node.name, node) + context.entrypoint = node.name +``` + +## Multi-Agent Routing (Only If Needed) + +Use `MultiAgent` + `MultiAgentContext` when you need conditional entry points chosen by `state["active_agent"]`. + +Minimal flow: +1. Build a `ContextFactory`. +2. Wrap it in `MultiAgentContext`. +3. Register builders that create named entrypoint nodes. +4. Populate `context.entrypoint_mapping`. +5. Build with `MultiAgent.make(context)`. + +If `default` is missing, `MultiAgent` auto-fills it from the current entrypoint. + +## Common Failure Modes + +1. `NotImplementedError: Agent factory must be provided` +Cause: missing `agent_factory` in context creation. +Fix: always pass `agent_factory` to `BuilderContext.create(...)` or `ContextFactory`. + +2. Model/key errors at runtime +Cause: default model path used without `OPENAI_API_KEY`. +Fix: pass key in context config, or provide custom `model_factory`. + +3. Unexpected graph start node +Cause: multiple builders set entrypoint; last set becomes current entrypoint. +Fix: review builder order and entrypoint assignments. + +4. Tools not being called +Cause: tools not appended to `context.tools` before director `make(...)`. +Fix: register tool builders before building workflow; keep each builder responsible for a related tool set. + +## Quick Starter Template + +Copy this into a new module and adapt names/prompts/tools: + +```python +from langgraph.checkpoint.memory import MemorySaver + +from assistant_core.builder import BuilderContext, SingleAgent +from assistant_core.nodes import AgentNode + + +def _agent_factory(model): + return AgentNode( + name="assistant", + model=model, + prompts=["You are a helpful assistant."], + ) + + +def build_assistant_graph(openai_api_key: str): + context = BuilderContext.create( + {"OPENAI_API_KEY": openai_api_key}, + agent_factory=_agent_factory, + ) + + director = SingleAgent() + workflow = director.make(context) + + return workflow.compile(checkpointer=MemorySaver()) +``` diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md new file mode 100644 index 0000000..9093045 --- /dev/null +++ b/ARCHITECTURE.md @@ -0,0 +1,209 @@ +# Assistant Core Architecture + +## Purpose and Scope + +assistant_core provides reusable graph-building primitives for agent workflows built with LangGraph and LangChain. + +This document covers assistant_core internals only, with emphasis on the builder subsystem used by downstream projects. + +Out of scope: +- Webhooks, workers, Redis queues, and channel integrations outside this package. +- Product-specific business logic. + +## Design Goals + +- Keep workflow composition small, explicit, and testable. +- Separate graph wiring from agent/tool/model instantiation. +- Make extension points stable for downstream packages. +- Support both single-agent and multi-agent entrypoint strategies. + +## High-Level Building Blocks + +The package is organized around five layers: + +- State types: typed state containers used by nodes and routing logic. +- Nodes: callable units that implement model invocation, prompting, and control flow. +- Context factory: pluggable creation of model, graph, nodes, and base tools. +- Builder context: runtime assembly state used by builders. +- Directors/builders: orchestration classes that mutate the graph wiring. + +## Module Map + +- assistant_core/models.py + - Model loaders and defaults. + - Default model is gpt-5-nano via ChatOpenAI. +- assistant_core/factories.py + - ContextFactory and the deprecated BaseAgentFactory compatibility wrapper. +- assistant_core/state.py + - QuestionState, NextProcessState, MultiAgentState. +- assistant_core/nodes/ + - BaseNode + mixins + concrete node implementations. +- assistant_core/builder/ + - BaseBuilder/BaseDirector, context objects, and concrete directors/builders. + +## Core Build Pipeline + +### 1) Context creation + +ContextFactory is responsible for creating: +- graph builder (default StateGraph(MessagesState)) +- model (default load_default_model with OPENAI_API_KEY) +- primary agent node +- resolver node (default name: resolver) +- base tools list (default empty) + +BuilderContext materializes these dependencies and keeps mutable assembly state: +- graph_builder +- agent_node +- resolver_node +- tools +- entrypoint + +### 2) Optional pre-builders + +Before the agent wiring is finalized, directors run custom builders registered through add_builder. + +A builder can: +- register extra nodes +- append tools to context.tools (prefer grouping related domain tools per builder) +- push a new entrypoint + +Entrypoint behavior is intentionally LIFO: +- setting context.entrypoint adds an edge from new_entrypoint to previous_entrypoint +- repeated assignments build a chain ending at the agent node + +### 3) Agent wiring + +AgentBuilder performs the canonical final wiring: + +- Rebinds tools to agent_node. +- Adds the agent node. +- Adds conditional edges from agent node using tools_condition: + - tools branch -> tools_ + - END branch -> END +- Adds ToolNode(context.tools) as tools_. +- Adds edge tools_ -> resolver node. +- Configures resolver.next_node to return to the agent node by default. + +Result: model decisions can invoke tools, then route through resolver for next-step control. + +## Directors + +### SingleAgentDirector + +Flow: +- Run registered custom builders. +- Set graph entry point to current context.entrypoint. +- Run AgentBuilder for canonical agent/tools/resolver wiring. + +Alias exported as SingleAgent. + +### MultiAgentDirector + +Adds conditional entrypoint selection on top of the same builder model. + +Flow: +- Run registered custom builders. +- Ensure entrypoint_mapping has default (falls back to current entrypoint if missing). +- Set conditional entry point selector from MultiAgentContext. +- Run AgentBuilder. + +The selector reads active_agent from state and chooses the matching mapped entrypoint. + +Alias exported as MultiAgent. + +## Node Architecture + +### Base contract + +All nodes inherit from BaseNode and implement async __call__(state, config) -> dict or routing command. + +### Mixins + +- UsesModel + - keeps base model reference + - supports bind_tools/rebind_tools +- UsesJsonModel + - structured JSON output helper +- UsesSystemMessage + - helper methods to emit SystemMessage values +- Include*Node mixins + - shared routing attributes (next_node, end_node, error_node, question_node) + +### Concrete nodes + +- AgentNode + - prepends system prompts to state messages + - invokes model asynchronously +- PromptNode + - injects formatted system prompt into message stream +- QuestionNode + - uses LangGraph interrupt for human-in-the-loop answer capture +- ResolverNode + - routes with Command based on state.next + - default goto is next_node; clears next after routing +- DataNode / ProcessDataNode + - abstract extension points for data-oriented logic + +## State Model + +- QuestionState + - question and answer slots for interactive steps. +- NextProcessState + - next field with replacement reducer for resolver routing. +- MultiAgentState + - active_agent selector used by conditional multi-entry workflows. + +## Extension Patterns + +### Recommended: ContextFactory with injected factories + +Use BuilderContext.create(...) or a custom ContextFactory instance to inject: +- agent_factory +- graph_factory +- model_factory +- resolver_factory +- base_tools_factory + +BuilderContext.clone(...) supports per-graph overrides while preserving the original configuration. + +### Compatibility: BaseAgentFactory + +BaseAgentFactory remains available as a deprecated wrapper over ContextFactory and is still used in examples for readability. + +## Example-Backed Workflows + +The examples directory demonstrates two key patterns: + +- Basic graph assembly + - create a factory + - build context + - register optional builders (for example TavilyBuilder) + - compile and invoke/stream the graph +- Entrypoint chaining + - multiple builders set context.entrypoint + - final graph preserves LIFO chain before agent execution + +## Guarantees Verified by Tests + +Unit tests enforce the following architectural behaviors: + +- BuilderContext defaults to agent node entrypoint. +- Entrypoint setter creates LIFO edge chains. +- Single-agent and multi-agent directors compile valid workflows. +- Multi-agent default mapping is auto-populated but not overwritten when already set. +- TavilyBuilder appends a tool into context.tools. +- DateTimeBuilder registers a pre-agent entrypoint node. +- ResolverNode emits Command values consistent with NextProcessState.next. + +## Runtime Notes + +- Environment values are loaded via dotenv in assistant_core/settings.py. +- OPENAI_API_KEY is required when using the default model factory path (load_default_model). +- A Tavily API key is required when using TavilySearch integrations; callers should read it from environment settings (for example via assistant_core/settings.py) and pass the value explicitly to TavilyBuilder. + +## Package Boundary + +assistant_core intentionally stops at graph construction and node primitives. + +Higher-level runtime concerns are out of scope here by design. This keeps the package focused on stable composition contracts for builders, contexts, state, and nodes. diff --git a/CHANGELOG.md b/CHANGELOG.md index fe37b45..0f22983 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,11 @@ # CHANGELOG ## NEXT +* Update example notebooks to use `BuilderContext.create(...)` and `agent_factory` instead of deprecated `BaseAgentFactory`. +* Add `ARCHITECTURE.md` for assistant_core internals. +* Add `AGENT_BUILD_REFERENCE.md` for from-scratch agent creation. +* Clarify that the README is contributor-focused. +* Clarify that `AGENT_BUILD_REFERENCE.md` is for external-library integrations, including grouped-tool builder tips and GitHub install examples (pip/uv/Poetry/PDM). ## v0.9.1 * Fix datetime node to always return the current time diff --git a/README.md b/README.md index 676ad39..1ff5e9d 100644 --- a/README.md +++ b/README.md @@ -48,17 +48,22 @@ See `CONTRIBUTING.md` for full contributor guidance. Common developer commands: Notes - Pre-commit hooks in this repo are configured to call the Poetry-installed tools (black, isort, flake8). Make sure to run `make install` before `make pre-commit`. +## Architecture and build references + +- `ARCHITECTURE.md` — package architecture focused on builders, nodes, and state flow. +- `AGENT_BUILD_REFERENCE.md` — step-by-step instructions to build an agent from scratch with assistant_core. + ## Project layout - `assistant_core/` — main package - - `nodes/` — Node implementations and mixins - - `builder.py` — Director/Builder for StateGraph composition - - `factories.py` — BaseAgentFactory (extension point) - - `models.py` — model adapter loader - - `state.py` — typed state classes used by nodes + - `nodes/` — Node implementations and mixins + - `builder/` — Directors/builders and build context + - `factories.py` — ContextFactory and component factory extension points + - `models.py` — model adapter loader + - `state.py` — typed state classes used by nodes Extension points -- Implement a subclass of `BaseAgentFactory` to provide a model and tools. +- Use `ContextFactory`/`BuilderContext.create(...)` to provide model, graph, resolver, tools, and agent factories. - Add new Node types under `assistant_core/nodes/`. ## Troubleshooting diff --git a/examples/basic_example.ipynb b/examples/basic_example.ipynb index d23452c..a490e52 100644 --- a/examples/basic_example.ipynb +++ b/examples/basic_example.ipynb @@ -27,11 +27,9 @@ "from IPython.display import Image, display\n", "\n", "from langgraph.checkpoint.memory import MemorySaver\n", - "from langgraph.graph import MessagesState, StateGraph\n", "\n", "from assistant_core.builder import BuilderContext, SingleAgent\n", "from assistant_core.builder.tavily import TavilyBuilder\n", - "from assistant_core.factories import BaseAgentFactory\n", "from assistant_core.nodes import AgentNode\n", "from assistant_core.settings import OPENAI_API_KEY, TAVILY_API_KEY" ] @@ -44,8 +42,8 @@ "### Why these imports?\n", "\n", "- `MemorySaver` is used as a simple in-memory checkpoint for interactive runs.\n", - "- `StateGraph` and `MessagesState` are the minimal graph primitives used in this example.\n", - "- The `builder` classes (SingleAgent, BuilderContext) show how to construct the agent workflow.\n", + "- `BuilderContext.create(...)` plus `SingleAgent` is the preferred graph assembly path.\n", + "- `AgentNode` defines assistant behavior through prompts and model binding.\n", "\n", "This import block is intentionally small to keep the example focused on the builder pattern." ] @@ -67,9 +65,9 @@ "id": "de3316da", "metadata": {}, "source": [ - "### The factory pattern (simple)\n", + "### Agent factory function (current pattern)\n", "\n", - "This example uses a minimal `BaseAgentFactory` implementation to create the graph builder and agent node. Keep factories small: they wire together model, nodes and prompts. To change system behaviour, edit `ASSISTANT_PROMPT` above and re-run the factory cell." + "This example uses `BuilderContext.create(...)` with a small `agent_factory(model)` function. This is the preferred architecture for new code. To change system behaviour, edit `ASSISTANT_PROMPT` above and re-run the agent factory cell." ] }, { @@ -79,18 +77,12 @@ "metadata": {}, "outputs": [], "source": [ - "class GeneralAssistantFactory(BaseAgentFactory):\n", - " \"\"\"Factory for creating a general-purpose assistant agent.\"\"\"\n", - "\n", - " def create_graph_builder(self):\n", - " return StateGraph(MessagesState)\n", - "\n", - " def create_agent_node(self):\n", - " return AgentNode(\n", - " name=\"assistant\",\n", - " model=self.model,\n", - " prompts=[ASSISTANT_PROMPT],\n", - " )" + "def assistant_factory(model):\n", + " return AgentNode(\n", + " name=\"assistant\",\n", + " model=model,\n", + " prompts=[ASSISTANT_PROMPT],\n", + " )" ] }, { @@ -101,12 +93,9 @@ "outputs": [], "source": [ "def get_assistant_graph():\n", - " context = BuilderContext(\n", - " GeneralAssistantFactory(\n", - " {\n", - " \"OPENAI_API_KEY\": OPENAI_API_KEY,\n", - " }\n", - " )\n", + " context = BuilderContext.create(\n", + " {\"OPENAI_API_KEY\": OPENAI_API_KEY},\n", + " agent_factory=assistant_factory,\n", " )\n", "\n", " director = SingleAgent()\n", @@ -134,7 +123,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] @@ -158,7 +147,9 @@ { "data": { "text/plain": [ - "'Message received. How can I help you today?'" + "[{'type': 'text',\n", + " 'text': 'Hello! How can I assist you today?',\n", + " 'annotations': []}]" ] }, "metadata": {}, @@ -190,7 +181,7 @@ { "data": { "text/plain": [ - "{'assistant': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_rjuqDK6M4H2QcxoR7qxO5qkp', 'function': {'arguments': '{\"query\":\"What is the capital of France\",\"include_domains\":null,\"exclude_domains\":null,\"search_depth\":\"advanced\",\"include_images\":false,\"time_range\":null,\"start_date\":null,\"end_date\":null,\"topic\":\"general\",\"include_favicon\":false}', 'name': 'tavily_search'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 459, 'prompt_tokens': 1390, 'total_tokens': 1849, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 384, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-5-nano-2025-08-07', 'system_fingerprint': None, 'id': 'chatcmpl-CJRhvdpcNgk4U4xU9H8sTiIc8yJqX', 'service_tier': 'default', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run--5e97dc47-4d51-4676-91ec-b34a678f58d8-0', tool_calls=[{'name': 'tavily_search', 'args': {'query': 'What is the capital of France', 'include_domains': None, 'exclude_domains': None, 'search_depth': 'advanced', 'include_images': False, 'time_range': None, 'start_date': None, 'end_date': None, 'topic': 'general', 'include_favicon': False}, 'id': 'call_rjuqDK6M4H2QcxoR7qxO5qkp', 'type': 'tool_call'}], usage_metadata={'input_tokens': 1390, 'output_tokens': 459, 'total_tokens': 1849, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 384}})]}}" + "{'assistant': {'messages': [AIMessage(content=[], additional_kwargs={'reasoning': {'id': 'rs_098cf6c9f126f8df0069b57d001dd8819eacb0241552d19a85', 'summary': [], 'type': 'reasoning'}, '__openai_function_call_ids__': {'call_H0Ud5KgSbKlFKy1vddXZFD1M': 'fc_098cf6c9f126f8df0069b57d01f06c819eba8931b2b1b85ba0'}}, response_metadata={'id': 'resp_098cf6c9f126f8df0069b57cff84c8819e9f0b7b3266544edc', 'created_at': 1773501695.0, 'metadata': {}, 'model': 'gpt-5-nano-2025-08-07', 'object': 'response', 'service_tier': 'default', 'status': 'completed', 'model_name': 'gpt-5-nano-2025-08-07'}, id='lc_run--019cecf0-417f-7e11-aaca-d5e7e230d4b1-0', tool_calls=[{'name': 'tavily_search', 'args': {'query': 'What is the capital of France', 'include_domains': None, 'exclude_domains': None, 'search_depth': 'basic', 'include_images': False, 'time_range': None, 'topic': 'general', 'start_date': None, 'end_date': None}, 'id': 'call_H0Ud5KgSbKlFKy1vddXZFD1M', 'type': 'tool_call'}], invalid_tool_calls=[], usage_metadata={'input_tokens': 1211, 'output_tokens': 397, 'total_tokens': 1608, 'input_token_details': {'cache_read': 0}, 'output_token_details': {'reasoning': 320}})]}}" ] }, "metadata": {}, @@ -199,7 +190,7 @@ { "data": { "text/plain": [ - "{'tools_assistant': {'messages': [ToolMessage(content='{\"query\": \"What is the capital of France\", \"follow_up_questions\": null, \"answer\": null, \"images\": [], \"results\": [{\"url\": \"https://en.wikipedia.org/wiki/List_of_capitals_of_France\", \"title\": \"List of capitals of France - Wikipedia\", \"content\": \"This is a chronological list of capitals of France. The capital of France has been Paris since its liberation in 1944.\\\\n\\\\n## Chronology\\\\n\\\\n[edit]\", \"score\": 0.89053273, \"raw_content\": null}, {\"url\": \"https://home.adelphi.edu/~ca19535/page%204.html\", \"title\": \"Paris facts: the capital of France in history\", \"content\": \"| | | | | | | |\\\\n --- --- --- \\\\n| Home | Spain | Sydney | San Francisco | Paris | Las Vegas | Maui |\\\\n\\\\nParis, France\\\\n\\\\n## Paris facts: Paris, the capital of France\\\\n\\\\nParis is the capital of France, the largest country of Europe with 550 000 km2 (65 millions inhabitants).\\\\n\\\\nParis has 2.234 million inhabitants end 2011. She is the core of Ile de France region (12 million people). [...] Paris remained the capital of France until today, with one four year interruption. During German occupation (WW2 , 1940-1944), the capital of France was Vichy.\\\\n\\\\ngo to top\\\\n\\\\nReference: [...] ## Paris facts: the capital of France in history\\\\n\\\\nBefore Paris, the capital of France was Lyon (under the Romans). Paris first became the capital of France in 508 under King Clovis. After centuries with no unique capital of France, Paris retrieved its status of capital of France under King Philippe Auguste, who reigned between 1180 and 1223. You can see remains of the Philippe August Paris walls in the passageway between the Louvre parking and Louvre Museum\", \"score\": 0.8877607, \"raw_content\": null}], \"response_time\": 1.64, \"request_id\": \"2c5f24bf-46d2-4818-93cd-069bd5176ed8\"}', name='tavily_search', id='f9ecab62-874f-460b-8c2d-c2e4a5873305', tool_call_id='call_rjuqDK6M4H2QcxoR7qxO5qkp')]}}" + "{'tools_assistant': {'messages': [ToolMessage(content='{\"query\": \"What is the capital of France\", \"response_time\": 1.28, \"follow_up_questions\": null, \"answer\": null, \"images\": [], \"results\": [{\"url\": \"https://simple.wikipedia.org/wiki/Capital_of_France\", \"title\": \"Capital of France - Simple English Wikipedia, the free encyclopedia\", \"content\": \"The capital of France is Paris. In the course of history, the national capital has been in many locations other than Paris.\\\\n\\\\n## History\\\\n\\\\n[change | change source]\\\\n\\\\n### List of capitals of France\\\\n\\\\n[change | change source] [...] Jump to content\\\\n\\\\nSearch\\\\n\\\\n## Contents\\\\n\\\\n Beginning\\\\n 1 History\\\\n + 1.1 List of capitals of France\\\\n 2 References\\\\n\\\\n# Capital of France\\\\n\\\\n Català\\\\n Ελληνικά\\\\n English\\\\n Español\\\\n Français\\\\n Polski\\\\n\\\\nChange links\\\\n\\\\n Page\\\\n Talk\\\\n\\\\n Read\\\\n Change\\\\n Change source\\\\n View history\\\\n\\\\nTools\\\\n\\\\nActions\\\\n\\\\n Read\\\\n Change\\\\n Change source\\\\n View history\\\\n\\\\nGeneral\\\\n\\\\n What links here\\\\n Related changes\\\\n Upload file\\\\n Permanent link\\\\n Page information\\\\n Cite this page\\\\n Get shortened URL\\\\n Switch to legacy parser\\\\n\\\\nPrint/export\\\\n\\\\n Make a book\\\\n Download as PDF\\\\n Page for printing\\\\n\\\\nIn other projects\\\\n\\\\n Wikidata item\\\\n\\\\nAppearance\\\\n\\\\nFrom Simple English Wikipedia, the free encyclopedia\\\\n\\\\n: This article is about the French national capital in general. For the current capital, see Paris. [...] Bordeaux (June 1940) The French government was relocated from Paris to Tours then Bordeaux very briefly during World War II, when it became apparent that Paris would soon fall into German hands.\\\\n Vichy (1940-1944) The Parliament abolished the French Third Republic here and replaced it with the French State.\\\\n Paris (1944–present) With the liberation of Paris in 1944, Charles de Gaulle established the Provisional Government of the French Republic, restoring Paris as the French capital.\", \"score\": 0.9291904, \"raw_content\": null}, {\"url\": \"https://en.wikipedia.org/wiki/Paris\", \"title\": \"Paris\", \"content\": \"### National government\\\\n\\\\nAs the capital of France, Paris is the seat of France\\'s national government. For the executive, the two chief officers each have their own official residences, which also serve as their offices. The President of the French Republic resides at the Élysée Palace. The Prime Minister\\'s seat is at the Hôtel Matignon. Government ministries are located in various parts of the city, many near the Hôtel Matignon. [...] Paris is the capital and largest city of France, with an estimated city population of 2.04 million in an area of 105.4 km2 (40.7 sq mi), and a metropolitan population of 13.2 million as of January 2026( Located on the river Seine in the centre of the Île-de-France region, it is the largest metropolitan area and fourth-most populous city in the European Union (EU). Nicknamed the \\\\\"City of Light\\\\\", partly because of its role in the Age of Enlightenment, Paris has been one of the world\\'s major centres of finance, diplomacy, commerce, culture, fashion, and gastronomy since the 17th century. [...] With 200,000 inhabitants in 1328, Paris, then already the capital of France, was the most populous city of Europe. By comparison, London in 1300 had 80,000 inhabitants. By the early fourteenth century, so much filth had collected inside urban Europe that French and Italian cities were naming streets after human waste. In medieval Paris, several street names were inspired by merde, the French word for \\\\\"shit\\\\\".\\\\n\\\\nDuring the Hundred Years\\' War, Paris was occupied by England-friendly Burgundian forces from 1418, before being occupied outright by the English when Henry V of England entered the French capital in 1420; despite a 1429 effort by Joan of Arc to liberate the city, it would remain under English occupation until 1436.\", \"score\": 0.8533396, \"raw_content\": null}], \"request_id\": \"8b387ca0-9f06-4eab-8c5d-6c235a5adef5\"}', name='tavily_search', id='6a6caadc-8863-4230-8306-349892ea545d', tool_call_id='call_H0Ud5KgSbKlFKy1vddXZFD1M')]}}" ] }, "metadata": {}, @@ -217,7 +208,7 @@ { "data": { "text/plain": [ - "{'assistant': {'messages': [AIMessage(content='Paris. Source: https://en.wikipedia.org/wiki/List_of_capitals_of_France (notes Paris has been the capital since its liberation in 1944).', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 553, 'prompt_tokens': 1936, 'total_tokens': 2489, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 512, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 1152}}, 'model_name': 'gpt-5-nano-2025-08-07', 'system_fingerprint': None, 'id': 'chatcmpl-CJRi2X8XztPFtAhovMSaWgFOyoTzB', 'service_tier': 'default', 'finish_reason': 'stop', 'logprobs': None}, id='run--415693fc-13bf-4039-85dd-c4c1ba4bac18-0', usage_metadata={'input_tokens': 1936, 'output_tokens': 553, 'total_tokens': 2489, 'input_token_details': {'audio': 0, 'cache_read': 1152}, 'output_token_details': {'audio': 0, 'reasoning': 512}})]}}" + "{'assistant': {'messages': [AIMessage(content=[{'type': 'text', 'text': 'Paris.\\n\\nSources:\\n- https://simple.wikipedia.org/wiki/Capital_of_France\\n- https://en.wikipedia.org/wiki/Paris', 'annotations': []}], additional_kwargs={'reasoning': {'id': 'rs_098cf6c9f126f8df0069b57d032064819e9be351ecd7df59ac', 'summary': [], 'type': 'reasoning'}}, response_metadata={'id': 'resp_098cf6c9f126f8df0069b57d02f000819eaee5046230d2aef0', 'created_at': 1773501698.0, 'metadata': {}, 'model': 'gpt-5-nano-2025-08-07', 'object': 'response', 'service_tier': 'default', 'status': 'completed', 'model_name': 'gpt-5-nano-2025-08-07'}, id='msg_098cf6c9f126f8df0069b57d04f2d8819eaabbdefd42e3ab09', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 2520, 'output_tokens': 318, 'total_tokens': 2838, 'input_token_details': {'cache_read': 1536}, 'output_token_details': {'reasoning': 256}})]}}" ] }, "metadata": {}, @@ -226,7 +217,9 @@ { "data": { "text/plain": [ - "'Paris. Source: https://en.wikipedia.org/wiki/List_of_capitals_of_France (notes Paris has been the capital since its liberation in 1944).'" + "[{'type': 'text',\n", + " 'text': 'Paris.\\n\\nSources:\\n- https://simple.wikipedia.org/wiki/Capital_of_France\\n- https://en.wikipedia.org/wiki/Paris',\n", + " 'annotations': []}]" ] }, "metadata": {}, diff --git a/examples/entrypoint_graph.ipynb b/examples/entrypoint_graph.ipynb index 894c2fc..a3b0a80 100644 --- a/examples/entrypoint_graph.ipynb +++ b/examples/entrypoint_graph.ipynb @@ -28,10 +28,8 @@ "from IPython.display import Image, display\n", "\n", "from langgraph.checkpoint.memory import MemorySaver\n", - "from langgraph.graph import MessagesState, StateGraph\n", "\n", "from assistant_core.builder import BuilderContext, SingleAgent, BaseBuilder\n", - "from assistant_core.factories import BaseAgentFactory\n", "from assistant_core.nodes import AgentNode, PromptNode\n", "from assistant_core.settings import OPENAI_API_KEY" ] @@ -48,18 +46,12 @@ "\"\"\"\n", "\n", "\n", - "class GeneralAssistantFactory(BaseAgentFactory):\n", - " \"\"\"Factory for creating a general-purpose assistant agent.\"\"\"\n", - "\n", - " def create_graph_builder(self):\n", - " return StateGraph(MessagesState)\n", - "\n", - " def create_agent_node(self):\n", - " return AgentNode(\n", - " name=\"assistant\",\n", - " model=self.model,\n", - " prompts=[ASSISTANT_PROMPT],\n", - " )" + "def assistant_factory(model):\n", + " return AgentNode(\n", + " name=\"assistant\",\n", + " model=model,\n", + " prompts=[ASSISTANT_PROMPT],\n", + " )" ] }, { @@ -69,12 +61,9 @@ "metadata": {}, "outputs": [], "source": [ - "context = BuilderContext(\n", - " GeneralAssistantFactory(\n", - " {\n", - " \"OPENAI_API_KEY\": OPENAI_API_KEY,\n", - " }\n", - " )\n", + "context = BuilderContext.create(\n", + " {\"OPENAI_API_KEY\": OPENAI_API_KEY},\n", + " agent_factory=assistant_factory,\n", ")" ] }, @@ -144,7 +133,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAM8AAALyCAIAAADymBdSAAAQAElEQVR4nOydB0AT1x/H32UwwhJQUUEZ4gTXX1zVunCPOuusitZZtY466kat1r3rrBv3KFq3dda9B24UFK0LQXYIJPf/JQcxQBIgkksu9/uUxsu7d+8ud9977/d+b4lomiYIwgoigiBsgWpD2APVhrAHqg1hD1Qbwh6oNoQ9zE5t9y9+fvU4MfGzIk1Gy9OzemcoIqAoheJLIEUpP7P5cCCQyhpNQBH4BuGaMSkBRSvobIEZewRE8/BcoIlITAnFpFBRcenKdmWqOhFEB5SZ+NvO7HkXEZackqAQCInYWiC2oiilRqgskSgQB0jkSwBsCnPIhaZoASWgNeVCKTWRXViqwIzPLGchqrPkuC05Y6qQ0wpQm0yqkKfRcrnydtrZC8vXcqjVojBBsmJ6tZ0I+e/5vRShiBT3sqnT1rVwcRvCZSIfJ9z65/OHKBmIu8q3TrVbo+a+YGK1rZv0HLKMGi1cqnzrTCyLf0M/PLgUb2MnDJrmTRAVJlPbvQux5/d/KlfdrmnP4sRy2b8i6m1E6sA53mKxkPAe06gtPka2ZearIQu8hULLfwZP78Sf2PxhyFxvoRXfBWcCtd05++nSodifFvgSPvHH6PD+00taO1gTHiMg7BIfk3rxb95JDWg1wG399CjCb9hW2455Uf9rxEePlHcFhxKlrTcERxAew6ra9q94LbKi6rQpQnhJ+yElZSmKiwc+EL7Cqtr+ey79boAl10BzBTxwd/+NJ3yFPbWFrnpt60AVKSkhPKZOm8LQRnLpb55mb+yp7e0LafkaDoT3uHlaP76RSHgJS2p7F5ksl5O6bYsSFnn+/HmbNm1I/tm9e/e0adOIcajTxgWagwkvYUltd87GWttShF0ePnxIDMLgA/NCcU+JQKhsSiH8g6UeRzHv0+ydjOVJT0hIWL169YULF2JiYipWrNiyZcv27dtDyJ9//gl7AwICRo0a1bNnz3///ff48eO3b9+Oi4vz9/fv378/7III4eHh3bp1W7JkyW+//ebs7Ozg4HDr1i0IP3z4cEhISPny5UlBY2VDRT2RVq5H+AZLapMmKYp4GMuNPn369Pfv30+YMMHb2xsKwd9//93Hx2fw4MEymezEiROHDh1SXoBUOnny5Jo1a0Jk+PrPP/+ABENDQ11dXcViMYSANHv16lW1alU/P7+goCBPT08mpjGwsRUkxKYS/sGS2uTptK2dsfI2yIp69+5du3Zt2B4+fHiTJk0KFSqULY6Njc3OnTttbW2ZXZC37d27986dO4GBgZSqTyYcDvkfYQUrG3FKspzwD5bURoGBKDBWgyxkSFDkff78+X//+1+dOnUqVKigNVpSUtKKFStu3rwZHR3NhMTGfjGedB1lDGiK1t4z09JhqZYgENPSZGNVxIKDg3v06HH58uXRo0c3bdp01apV6enp2eK8e/cODLW0tLTZs2dDzCtXrmSLYG3NXnu5TCoXitmuM5kDLOVtYitBQkw6MQ6Ojo79+vXr27fv3bt3z5w5s379erD0f/jhB804J0+eBDMOTDEoTEnWXI19UhLlhT243UXZMFhSm1Nh8btIo9jFUME8duxYu3btwDKrquLJkyePHz/OGQ1EyUgNOHXqFDEdslQaWugJ/2CpJK1Yx14mNUpJKhKJ1q5dO378eMjYPn36BG4LkBpoDnaVKlUKTLSzZ8++fPmyTJkysL1v3z4oZC9dunTt2jWoLkDxqjXNkiVLhoWFXb9+HVwqpKBJSpDRclKrGR/HKwjB6CHGx8XN5vqJGCtrUszLlhQoVlZWlSpVgoJy48aNUFeIiooaMGAA+Nugplm4cGHw027atAmE1bVrV7lcvn379mXLlkExOmnSpOTk5K1bt4IEK1euvGvXrlatWnl4eDBpgtcNnHM7duyoVauWOrCgOLrpbWJseo1mLoR/sNd3d+eCl1BRCJrK9yEh6yY+965k36S7G+Ef7LXKfz/KIzGWj04mTR5ejUtNofkpNcLmWHmhUFioiGjzb5F9JntpjXD+/PmpU6dq3eXk5ARmvtZdUGiOHDmSGAdIGTzAJJ+XBMZJw4YNte46t++jt38B2xIcgu1RMCtGh7fs61a6kpauR2C/p6SkaD0K/GRM+1JOIBxqo8Q4gG0H1h7J5yVBzRfqLjnDT+949/R24uB5vBuToYbteUDqd3A+vuX9T/O1qA2eEPjJiDkhkRRk38+H1xIH/laK8Bi2R8FU/tbVq6Lkz8nPCc9YNS68bnsXKzsrwmNMM3r50fXPp3dFD+XNOL8Vo8I7/exe3Ju/FhuDyWZmOLLhv5ePkpv0LGLZU1BdPPjh9tn4bzu4VPmWjw62bJhy1pn7lz5fCI12dBH3/NWTWBxvX6Uc2/A2NUXRY5yHoysfW0VzYvoZtXbMfxXzVubgKqxcz6lqA0vIACA/e3IzCZreS5S26fBTATdFcBpzmS1wz+KoT29lCgVtZUvZOYht7YU2tpSC+lKJ0ZyGklLN/UcRSkFnmacyY69mTOV0lrRcQTF71Z/MD88SqIrMTGGpPIGCmQqTKBRZLoA5QJk2DR5EAu4RAa1ITycyWXpSnDw5QZ6eSoRiqri3TbvB7gTJirmojSEiLPHRjfiYt2mp4OdKp+WafZQo5X+ZVwtCUQoxy8Wr546kVJuZewQCjVlRQT1yhXJiJeZIjTkradWEqWqNMhsCIaWQ0xoXQJQSpTKOZvaq0qBt7CmxjbCou83/GjkVdud7bUAX5qU2YwNt8D179jx+/DhBTAG/5hSH5gqtXn6EHVBtCHug2hD2QLUh7IFqQ9gD1YawB6oNYQ9+3Xo9XSARFsC8DWEPVBvCHqg2hD1QbQh7YC0BYQ/M2xD2QLUh7IFqQ9gD7TaEPTBvQ9gD1YawB6oNYQ+25wExLag208IvtWEtwbRgSYqwB79uvUQiMd7Ugkiu8EttUqk0OTmZICaCX2qDYjTnokQIa6DaEPbgl9qgQgrVUoKYCH55QDBvMy1YkiLsgWpD2APVhrAHqg1hD1Qbwh6oNoQ9UG0Ie6DaEPZAtSHsgWpD2APVhrAHqg1hD16sBdOnT5979+5RFLO2FbNeFVEoFLrWjEeMBC/6gPz8889FixYVCARCoVCgAgKrV69OEHbhhdpAWP7+/poh9vb2PXv2JAi78KV/W79+/dzc3NRfPT09GzduTBB24Yva/Pz8qlWrxmxbWVlhxmYSeNR3NygoCKw3osrYWrRoQRDWyb1O+upp0rNbCanS7OEC1UrFWdKivqxBm7mecZZA9T5CZ4/PrGOcPZGcx6rDVWsj64qsdRtqow8ehL19965c2XIeHh7Z01cvpqtxlKoCm/0O6bqqHKfTHk2QucKzzp+Z9Uq0IoQc2o5UaWzv4mpPuEMuals/NTw1mYitBWmp2aNlWdOYSUvz2WTeQkqQoQyi5fFrqo2Sy5n4FJ2ZbMaxOZ6HckluQlM0pXkNmnG0hkPC4P9Qrpac6QRRp6/1FDrVpnFUTtSn1vwhWSMoVw/XdeWEaD9pzkQEIipNpnB0FvSa5EM4gj61rfk1vLC7qFlvL4KYK/tXhAsoUa+JXoQL6FTbuknhHmVs6nXwIIh5c2htpCxV0WcyB3I47bWEy4c+KOQEpcYJ2gz0SoxRvH+VSMwe7Wp79Uxq44BzAXEGa1vq3r8cUJt2SaUlK4iCIFwBqj/SeA48MO1qk0OVT0ERhCMo0uGRcaB3BRaXCHug2hD20F5LUBaiPOj3hrCM9rxN5QtHuw0pYHTkbQLUGlLwaFcbtOJRAixJkQJGhwckXYEeEKTAwTqpJUAJlV1CiNmjXW1otXELWumN5653lyZ8GPlnOdD6utyZDzrUBrUEFBtS0Givk0K2jFlbHjlz9mSjwIDPn2OJoaSmpm7avLZf/64tWtX9cUC3NWuXSaVSYoloz9tAg3JiMrn9Fbr78ZMHE8ZPJ/xg6bK5/1443aplez+/yjduXNm5a4tcLv9pyChicWhXGzMYgJiIJ08eEt4QHf3x6LGD48dNa9G8LXyt/23jxMSEq9cu8khtVP7NNngd9+zdtnnLWtiuWKFSUJ9BlSpVhe2Wrev16T2wW9feTLR582c8f/50zeoQ2H71KnLjptV37t6EYhte625desMhI0cPvHv3Fuw9ceIwRCtbpvzFi+cg2ZevIpycCvn6lhsxfLybWzGIMH3Gr3CddWp/O3/hTKFQWL6cX/C0uaEH9kBkR0en5s3aDB40gtJbu4ZMdGvIn0sWrZ02fVxk5AsfH9/vO/dknjqg67zA6jVLT5w8LLGVBAa28PDw1Ezz2PG/D/69LyIi3Nvbt3GjZp06dtd/DYULFzlz6oZmiFAkshJbEUtEx3hSOt/l6Np1yw8c2DNj+oLJE2cVKeI2fsJwEJOe+DKZDIQFKpk7Z/nC+atEQtGkyaPAXoFnX6GCf7NmreEZgNRu3Lw6NXgsfN2988i0KXPev3+7ZNkcJgWRSBT24C787dl1dPXKrbAxYtQAhUJ+6OC5aVPn7N4TcvXqRf3XLBaLISNZtnze2F+mnP7neoP6TeBleP/+HezSc94DB/ceOLhnxM/jV67cUry4+5at69QJ/nPq2Nx50+Gyt4cc7P/j0L37tq9YuZDkGXjr9u/fee7cP717DyCWiI46KZW/Yc1x8XHwdEeO+LVGQG34WqtW3eTkpE8x0aVKeek6JCrqZWxsDLz68GzgK+jj7r1bOae72rBxFRQunTv1gG3IY34aMnrM2J8eP3lYvlxFopLssKFjQDSwy8fbN12e3jdoMIRXqxpQqJDz8xfPateup/fClasxQ9ZbsWIl2IbsEPLa8PAnkIfpOe/+v3aCLhvUD4RdkBE+ehT2+vUrJrUjR0IrV64G9wG2nZ1d+vYZPG/BjB969INtkhtMpg6/BX7Rt/UakfxACYhAyAEfqa520vyNoo+MeA6f5cv7MV8h15kxfT48cj2HeHiUAkHMmRccsm1DWNhdgUAA8e3ts4/FffHimTpZoFxZpcgeP37AfHV3L6leudtWIvHy/DLuyE5iB/kWyQPq9B0cHOGTOUrXeSH7efMmysvry4nKlq3AbCgUCshfawTUUe+qVq0GBN67f5vkARD0ooWrW7b4bvmK+WCTkPwAzjaFnLPeXbmczlc7KfOEbKzzsayxtbX10sXrDh8JheJm/YaVJUp4BPUe2LRpq6zJJoJ3wFojWYlEAp+QcTJfmbmx1GT7mkdy2lV6zguAhWprK1HvsrGxZTYgo4WcEn4L/GmmBlk4yQNMHg+vHNghf67/o3WrDsxJ8/YbuNH8UzDtpHZ2yjxJLQI9yBVy9TaUs0MGj4Sy79ata1Avmz1nqqeXD3PTGZhVuaXSFHVIkuoUri6FiTHRc147OzuwNVM1JqpISUlWHwX6aNa0dX1VIaumRHF9AyWhTnrx0rkmgS0hZSYETAIQ7tu3b0qXLkPyCM2Nzq86SlIqf7UEqLJB6QmGF/MViptfJ444fvwQUU4oiT/L6wAAEABJREFUZK1+HkRlrjEbUIcAhRHVQ/rmm/pQnYQUnj59pJkshJQrW+HBg3vqEGbbJ++PwSD0nBcyQje34pq7rly9oN4uXbpsQmIC5E/Mn79fFRBo0aJues714cO7JUvn3L59XR3yIiIcPgsXKUosDu1qU9D587aBvdW0SSuok4KAbt+5AZbHzZtXoWoJu8AAP3f+FJRNsL01ZH109AfmkPj4OKgArlq95PWbKJDgtu0boYoAj4eorDEwvW/dvg5lUIf2XS9cPLtv3474hHhIeeWqRf+rVqOMbzliZPSct1HDpuf/PQ1NCLC9Y+fmhw/vq48a8OOwixfPHjl6AMy1+/fvzJg5YfSYwZBR6TkR3CXw/qxYuQDuEpwIHCg7dm6CyoeToxOxOLSXpEKhQJ5POwA8AvCOLlw0C8wa39JlZwTPZyqkUMNauPC3tu0aQobRtUuvwMYtoNyEcH//KqNHTdy0eQ1UZuFrQPVaYCMz1nfb1h0hkxs7big4R8AH8TH6w649W8GVAFXFgOq1B/QfRoyPnvP+0PNHaKeCNwrEBA5CsO5nzZ7MtPTB17Wrt8Gbo2p9SvGrWPm3mYvAQtVzIsgsZ05fsOKPBb/PmQrGooO9Q4sW3w0ZNJJYItrnAdk8MxJqCZ1GehKEC2yf9cLN07r9UHdi3uhoJxVS2CqPFDi6+7cRS2DCpJFh97VPU9+qVXuoERPjAwbcxEk6TxSyNRS8x4Qf6Oy7S1tE990xoyfL0rQb6RLbPHuzvg6lMbd2u669BSI1SgR/nO0prpwm0iJGwbi6Gtczl0eKFytBjAmdDn+cbUtQzktKEKSA0TFWHvxtllGUIuaEjrHylNI3QhCkQCmYVnkEyQs62klFlEHdKRBEHzr8bQqcUAspeHS0yitoToyGRbiFrpYrgaW0JiBmhI4RfnKc4wgpeLSrzcpWSKejf5cziGwosTUxf7TbbbZ2RCpFtXGGNKm8UDEOTI6mXW2NuhROSUS7jRu8fBwHDoS6bdyI2aNdbU6utsW8rbb9Hk4Qs+fffR/L13IgXEDfipFXjn28fTquuI/EvYytrcQql1R0DzGjdc8pkrEKaM7lX3NZEZZZTpboPFeOw/Wml3FQjuvUHk4re2NR2VJkAmnV60vnjKzjjNkuTh2quZtJIfv10yQpUfbqUUL0a1nbQcU8fLmxJm4uq+GC4B5dSZQmy+VphGUyZKgD/QsgG5CgtgN0vCV0vmbk0apzHeLXlrL2s1GUyIq2taO+6VCkjL8j4QgUryZq+/TpU/fu3U+cOEEQU8CvWZ7T09NFIpzY2mSg2hD2QLUh7MGvW5+WlqaeEwlhH8zbEPZAtSHsgWpD2APVhrAHqg1hD1Qbwh6oNoQ9UG0Ie6B3F2EPzNsQ9kC1IeyBakPYA+02hD0wb0PYA9WGsAeqDWEPfs3ShmozLfxSG9YSTAuWpAh78OvWOzo65lzeGWENfqktISEhHwsaIwUNv9QGxSgUpgQxEag2hD1QbQh78MsDgmozLZi3IeyBakPYA9WGsAeqDWEPVBvCHqg2hD1QbQh7oNoQ9kC1IeyBakPYA9WGsAeqDWEPXqwF06FDh8jISIpiluOiBAIBbCgUitu3bxOERXjRB2TIkCEODg4gMqFQCJ9EueYV7e/vTxB24YXamjVrVqZMGc0QW1vb77//niDswpf+bf369YPsTf3Vw8Pju+++Iwi78EVtdevWrVixIrMN5WmnTp0Iwjo86rsbFBTEZG/u7u6YsZmEPHlAIh7FK9KEmiHKRYazrkfLrKJMNBZ61Vw0OC9Lwqq/qjYyF1HOchYtK8MKCK3IDNS1wDIT7mJd8ZuqHR8/fBhYu8mbp3JCkrRdQ8avyHE9X34R0QWl2q8b5upzJqstVi6LT0Mtx8ZO4OHLsdGKuXhAds6PiHkvh0cuz+qlyvc6xhmHkVxXvS44clksvMDJ/Xfk5Zfm+W4IRIQSEHdv6+8GlyQcQZ/ats2LSE1SfNuhaDFvB4KYH8/vx1w+FOPjJ2neqwThAjrVtmn6C6EVaf+TD0HMm90Lwh2chV1GexOzR3st4cHlWGmSAqXGCTqN8o5+IydcQLvaHl2Lt7Hn11BT7gIOHSiFTu/8j5g92uukqVJKiDNPcQeRUJScQMwf7ZJKlylohVEqiogxgOeVLuNA7wrMwBD20G6cUZivcQpwvFECDjwz7XkbD/q8WRSgNgEXKnVYkloCCrnyz/zRrjZltozZG4eguVEe6bDbaD50ILcoOPG4tOdtCpQapxCIKYEVZ2sJCLdQpNEK9LchLEEpq6Xmj65aAkcMAYSBVvYpNX905W3o3uUSlJASCDnwyLTnv7QC66R55czZk40CAz5/jiWGAvd60+a1fX/s0rzlNz8O6LZp8xqZTJa/FKBZm7t5G0UTuemK0r9Cdz9+8mDC+OmEH2zbvnHb9g1DBo/y9i79/PnTlasWp6en9/9xaL4S4YSDVEfLFUUEtMly5idPHhLekJqaGrJtfa8f+nfs0BW+VqsaEBZ298LFs/lTG82NxkYdeVv+lSaXy/fs3bZ5y1rYrlihUlCfQZUqVYXtlq3r9ek9sFvX3ky0efNnwOu7ZnUIbL96Fblx0+o7d29CUeLnV7lbl95wyMjRA+/evQV7T5w4DNHKlil/8eI5SPblqwgnp0K+vuVGDB/v5lYMIkyf8StFUXVqfzt/4UyhUFi+nF/wtLmhB/ZAZEdHp+bN2gweNILS+0sgE90a8ueSRWunTR8XGfnCx8f3+849WzRvy+zVdV5g9ZqlJ04elthKAgNbeHh4aqZ57PjfB//eFxER7u3t27hRs04du+u/Bmtr680b98GnOqRo0WKQtRNLRFcfECq/ilu7bvmBA3tmTF8weeKsIkXcxk8YDmLSEx9MExAWqGTunOUL568SCUWTJo+SSqXw7CtU8G/WrPWZUzdAajduXp0aPBa+7t55ZNqUOe/fv12ybA6TgkgkCntwF/727Dq6euVW2BgxaoBCIT908Ny0qXN27wm5evWi/msWi8WJiQnLls8b+8uU0/9cb1C/CbwM79+/g116znvg4N4DB/eM+Hn8ypVbihd337J1nTrBf04dmztvOlz29pCDkDnt3bd9xcqFJDdAxIUKOTPbaWlpV69dLONbnuQHgRU4eDngAtF+iQpF/pqu4uLj4Ol269anRkDtunUbjPllckD12p9iovUcEhX1MjY2Bl59eDalS5cBfUyfPj/ndFcbNq6q/23jzp16QAYD+d9PQ0ZfuXLhcWZRC5IdNnQM7PL09Pbx9gXt9g0aLJFIoDyC5/f8xbPcLlz5dCHrrVixErxgkB3Crw4Pf6L/vPv/2gm6bFA/0NHBETLC/1WroU7tyJHQypWrjRzxq7OzC4T37TM4NHQ3/EySZ6BUff36Va9e/Ul+UMjAwcuBaoJ2tQkoKl9ZW2TEc/gsX96P+Qq5zozp8+GR6znEw6MUCGLOvOCQbRvAUhEIBBA/51K1L148UycLlCurnF3h8eOMgsbdvaR65W5bicTL88uwHTuJHeRbJA+o03dwcIRP5ihd5wU5vnkT5eX15URly1ZgNhQKBeSvNQLqqHdVq1YDAu/dz+u8XVtD1sNLu2D+SngDSb7gtHdXlbXlQ27ME7Kxtsn7IWCpLF287vCRUChu1m9YWaKER1DvgU2btsqabCIY0dYayTJr2SYnJzFfBVl7dQkM6uSV88XSc14ALFRb2y+D1G1sbJkNyGghp4TfAn+aqeUlb4NjZ82efP3GZSi19b+l2uG0dze/bQl2dso8SS0CPcg1+mGVKuU1ZPBIKPtu3bp29NjB2XOmenr5aL7WNjbK5y2VpqhDklSncHUpTIyJnvPa2dlBeZ2aKlXvSklJVh8FomzWtHX9+oGaqZUo7kFyY9786XATVv2xBUwCYrnoqCXksy0BqmxQet69d4v5ChnjrxNHHD9+CLatrKzVz4OozDVmA+oQoDCiekjffFMfqpOQwtOnjzSThZByZSs8eHBPHcJs+5QuQ4yJnvNCRujmVlxz15WrF9TbpUuXTUhMgMyJ+fP3qwICLVrUTf/pDh3+6/KVf2fPWmKw1IRWApGYs20Jiny2JYC91bRJK6iTgoBu37mxfMX8mzevQtUSdoEBfu78KSibiMouiY7+wBwSHx8HFcBVq5e8fhMFEgQPJ1QR4PEQlTX26FHYrdvXoQzq0L4rOJ/27dsRnxAPKa9ctQis7zK+5YiR0XPeRg2bnv/3NDQhwPaOnZsfPryvPmrAj8MuXjx75OgBMNfu378zY+aE0WMG628YgGr4mjVLwY+TLk+HE6n/oFAmeUYuU6Sncda7Swmo/HoLwSOwZOmchYtmgVnjW7rsjOD5UFBCONQZFy78rW27hpBhdO3SK7BxCygyINzfv8roUROhlQbsYvgaUL3WooWrGeu7beuOkMmNHTcUnCPgg/gY/WHXnq3gSgBPAVR1B/QfRoyPnvP+0PNHaKeCNwrEBA5CqK6CycW8nfB17ept8OasWbsMCmK/ipV/m7lI05eWk1dRkYlJiadOH4c/zfC9u4+5uhrXYGAf7fOAbJ4ZSSuoTiM9CcIFdsx+4eZl3W6IOzFvtOdtAmXeht1AOAPN6TqpwlL6gEyYNDLs/h2tu1q1ag81YmJ8wICbOEnniUK2hoIDmXwdYPlQIs72FBcKKLlFdHEbM3qyLE27kS6xZWliR6Uxt3a7rr1fLzUVNCfGkmhXmxzyNi7kzLliJoZ28WLGnc0PHhaXvbtosyFGQOfMDNh1l0tQ3MggdLdcIRyC070plTmbRdhtPIESUkLu1kmxJOUWtJyWp3O55QrlxiE4Pn8bR2rUCIPqeXF2jiOl4YZOEKSgwXlAEPbQrjYrMZWOc4pzB0qsEIg4OwrG2p5SpHNjeRGEqHwIToWtiNmjXW1V6jskJ6DauEFiYkpaKmnQyY2YPdrVVrqys72zaN/SFwQxe/7+442HLwcyNqJ/xci//ngd/Z+0akPX8jWdCWJ+3D7z4dGV+Er1nL5pU4RwgVxWw/1rZdT7lzLwUxfYhE25rvaqP0Iuy/DqPFj5O7UdqDM8X0MctZ1WSBF5jiRyXn7OBZu1hWS/SErl0RWJiVclu+Y9ixOOQOWlk25KbEpiilDLwdmWyaZVC29nWf5bdeuyrNZNqaZQonK0jWmsgK3cpHM+bypzCXDNxDV3QcI0Reu4NuV/CQkJUyZPXrp0GZ15DdmuRH2plGpN7y/pk4xVwAU0paDobJEFNPlSg88MVaescQqKYu63ZhzV0uJUxv1T7aNVvyNDw1++MRLM/F1yFzcroVDLQzFn8uRvs3W2tbWIspT+II9JjCxcQkwQU8Av7256eroIV8I0Hag2hD1QbQh7oNoQ9uDXrU9LS1PP94awD+ZtCHug2hD2QLUh7IFqQ9gD1YawB6oNYQ9UG8Ie6G9D2APzNoQ9UG0Ie6DaEPZAuw1hD8zbEPZAtSHswa9JKPDlKw8AABAASURBVLEkNS38UhvmbaYFS1KEPfh16x0cHBwdHQliIviltvj4eDs7O4KYCH6pDYpRKEwJYiJQbQh7oNoQ9uCXBwTVZlpQbQh7YEmKsAeqDWEPVBvCHqg2hD1QbQh7oNoQ9kC1IeyBakPYA9WGsAe/1CYWi9PS0ghiIjBvQ9gjT2vBcJ1OnTqlpKTI5XKpVJqcnGxlZQWak8lkt2/fJgiL8KJVHtQWHR396dOnpKQkeLtSU1NBeWXKlCEIu/BCbT169PDy8tIMEQqFLVu2JAi78KXH0Q8//AAFqPpryZIlO3ToQBB24YvavvvuO29vb2aboqhGjRoVKlSIIOzCo96UQUFBEomEqDK2zp07E4R1eKS2pk2b+vr6wkaDBg3c3DiwCrvlkYsH5J+d/0XcT0lLpeXybIflWB84D4sV52Wd4TwmlQt6FnDWvUv/eXWt0pyHU+Yp/cxUaCq3dJikBCJibUNVbeBQvUlRwhH0eXdP73737Hayt79D2er2AlGWyVoojVWOM0Ky38psKyXrOCozRLUCNp2Zjtbnkj0wS8xsz5pZUzkrzCnUZ9RzMZrHqJNV7aPzoNQvmzneJR16ozMXnCZ5RUjJkxPlT27GXTkeb1fIunyAE+ECOvO2XQtfxsWmdR/rSxDzZvvv4Z5+kha9ShCzR7vd9iYy8dNblBo3aBrk/vxuMuEC2tV27WisraOQIFygSHFbsZhcOPCBmD3a7TZpglwkzt1WRcwEoVjw+QMHehtoV5ssldAKVBtnSJeSdBkHelfg1HkIe6DaEPbQXksQiQQUv2YIQdhAu6bS0xW0giBIwYIlqUVAEYoLlTrteRsUo1gj5RLQRMaFDv/a8zYK3hS025CCRrvaFHIa/W1cAsoiAQeeF9ptFgMHilLt5aVAQHHC6kQYuPKstOdttNLqtPxxphYDuKs44bHSpTaaOy8Mwhl0lKRCbvhvzIEzZ082Cgz4/DmWfAUKhWLjptWQzp6920j+UfVF5sAD064202bLf4Xu/n3uNMIb4uI+j/91+PEThwQCA91OSqFxwfLRoTaTegufPHlI+MTRYwflcvnaNduFQsN7sHKiKNLh3RXku0IN9wtKgc1b1sJ2xQqVgvoMqlSpKmy3bF2vT++B3br2ZqLNmz/j+fOna1aHwParV5FQfNy5exPMRD+/yt269IZDRo4eePfuLdh74sRhiFa2TPmLF89Bsi9fRTg5FfL1LTdi+Hg3t2IQYfqMX6HmXKf2t/MXzoTnVL6cX/C0uaEH9kBkR0en5s3aDB40Qn/VGjLRrSF/Llm0dtr0cZGRL3x8fL/v3LNF87bMXl3nBVavWXri5GGJrSQwsIWHh6dmmseO/33w730REeHe3r6NGzXr1LF7rtX7ut806PL9DwZnbAycqNPp+oX5HmW3dt3yAwf2zJi+YPLEWUWKuI2fMBzEpCe+TCYDYYFK5s5ZvnD+KpFQNGnyKKlUCs++QgX/Zs1anzl1A6R24+bVqcFj4evunUemTZnz/v3bJcvmMCmIRKKwB3fhb8+uo6tXboWNEaMGKBTyQwfPTZs6Z/eekKtXL+q/ZrFYnJiYsGz5vLG/TDn9z/UG9ZvAy/D+/TvYpee8Bw7uPXBwz4ifx69cuaV4cfctW9epE/zn1LG586bDZW8POdj/x6F7921fsXIhyY2SJT2/UmrKx8gF766OdlKKUPnJm+Pi4+DpduvWp0ZA7bp1G4z5ZXJA9dqfYqL1HBIV9TI2NgZefXg2pUuXAX1Mnz4/5+RqGzauqv9t486dekAGA/nfT0NGX7ly4XFmUQuSHTZ0DOzy9PT28fYF7fYNGiyRSKpVDShUyPn5i2e5XbhypXnIeitWrAQ5EGSHkMuGhz/Rf979f+0EXTaoH+jo4AgZ4f+q1VCnduRIaOXK1UaO+NXZ2QXC+/YZHBq6G34mMTZgZys4a7cRPSMntREZ8Rw+y5f3Y75CrjNj+nx45HoO8fAoBYKYMy84ZNuGsLC78HJDfHt7+2zRXrx4pk4WKFe2Inw+fvyA+eruXhLyJ2bbViLx8vRRx7ST2EG+RfKAOn0HB+WyzMxRus4LcnzzJsrL68uJypatwGxAvRLy1xoBddS7qlWrAYH37ht9ljhl7sCFdm0d/jYFtJPm411hnpCNtQ3JM9bW1ksXrzt8JBSKm/UbVpYo4RHUe2DTpq2yJpuYmppqrZEsM5FHcnIS8zVbAWRYeZTTrtJzXgAsVFtbiXqXjY0tswEZLeSU8FvgTzM1FvI2Za2Ow95diuSr6crOTpknqUWgB7niyxQPpUp5DRk8Esq+W7euQb1s9pypnl4+ULCqI9jYKJ+3VJqiDklSncLVpTAxJnrOa2dnB+V1aqpUvSslJVl9FIiyWdPW9esHaqZWorgHMTbc7t+WP7ONQJUNSs+7924xX6G4+XXiiOPHD8G2lZW1+nkQlbnGbEAdAhRGVA/pm2/qQ3USUnj69JFmshBSrmyFBw/uqUOYbZ/Sxp1WUs954SV0cyuuuevK1Qvq7dKlyyYkJoBJwPz5+1UBgRYtysYMNzQXfCAFU0sAe6tpk1ZQJwUB3b5zY/mK+TdvXoWqJewCA/zc+VNQNsH21pD10dEZg2zj4+OgArhq9ZLXb6JAgtu2b4QqAjweorLGHj0Ku3X7OpRBHdp3vXDx7L59O+IT4iHllasWgfVdxrccMTJ6ztuoYdPz/56GJgTY3rFz88OH99VHDfhx2MWLZ48cPQDm2v37d2bMnDB6zGAoYfWf68nTR3AK+GOMQmYbinKSd2hueHd1tpPm99rBI7Bk6ZyFi2aBWeNbuuyM4PlQUEI41BkXLvytbbuGkGF07dIrsHELKDch3N+/yuhREzdtXgOVWfgaUL3WooWrGeu7beuOkMmNHTcUnCPgg/gY/WHXnq3gSgB3F1R1B/QfRoyPnvP+0PNHaKeCNwrEBA5CqK7Omj2ZuWHwde3qbfDmrFm7DApiv4qVf5u5CCxU/edaumwuvF3Mtsq9shc2toUcKFHcnVgW2med2TwzklZQnUZ6EoQLbJ/1ws3Tuv1Qc1en9rxNIKCwwxGXoLjccgV2ABechbkzYdLIsPt3tO5q1ao91IiJ8QEDbuIknScK2RoKDmTytdCc6P6qQ2359ICYLVMmzdb0uWgizjr/ofEAY2779r917XWwdyBfD00puFtLUCgspOsu45U1OQUjKT1wpC0BxyVYAtwel6AC5cYZuN1yxUyHTBCkQNFltxEKZ53hDsrJ0AkH0NGWwI2uoEgGFEdKIu1qE4qENGZuSEGjXW3yNDnOA4IUONo9IEKBgBuGAMIpdLSTiogQTTfuQIkogZCz4xLEVuC+QbuNM9C03NaJs70pvavYSeMxb+MM8jRSp5kLMXu0qy2gcWGxmJwMeUkQs+evPyIcXQX2rrbE7NG3PumfU55b25H2Q0oTxCxJSpQdXvPKwcWqy8hShAvkshru5pkvkuIUAiGRp+fVLFC2etFftvV6irUtI5pxFE3nZz1bHcuUqq9HV7j2E6hWSs1+YbrSUV9StgT1xNcMVR+l+3q0XbyACIV0uoy4FBd3H8uZLtZUrl2LZCmyW+fjZIk6I+RYLjjrrA765njQuvRyZqo61KZjh57TfNklk6Vdu3atXr26mWdXaO30qlpkmdYiaZ2vAJV5XbTW8+Y8gZYRebrkpu0mQVRbJ2FAE1fCKSgL6ciWNz5+/NirV69jx44RxBTwa5bn9PR0kQgntjYZqDaEPfh169PS0tSz1CDsg3kbwh6oNoQ9UG0Ie6DdhrAH5m0Ie6DaEPZAtSHsgWpD2APVhrAHqg1hD1Qbwh6oNoQ90LuLsAfmbQh7oNoQ9kC1IeyBdhvCHlyYG7jgQLWZFixJEfbg162XSCR2dnYEMRH8UltiYmJKSgpBTAS/1AbFaM6l6xHWQLUh7IFqQ9iDXx4QcH+AE4QgJoJfasO8zbRgSYqwB6oNYQ9UG8IeqDaEPVBtCHug2hD2QLUh7IFqQ9gD1YawB6oNYQ9UG8IevFido2fPnjExMQKBQCqVJiYmFi1aFH51SkrKqVOnCMIivGiVb9CgAajt/fv3cXFxcrn87du37969c3JyIgi78EJtXbt2LVUqyyp3CoWifv36BGEXXqgNsrG2bdsKhUJ1iIeHR8eOHQnCLnzp39alSxfN7K1mzZrZcjuEBfiiNhsbGyhPra2tYdvNza179+4EYR0e9d3t3LlziRIlYKNatWqlS+OC0iaAVQ/I/pVRn/5LVaRRjM+LWRCWWZ+YojNXm9X8zFjUWBlNofr65RDVv5mrO2ekBgcpMheOzRoz86uCVijkAqGQoijmLAo6y1K+6qM0V7LNsjwyyVibNudqz5TGBdFZFu3N2BZZ0WKxoJiXdat+7oSXsKe2lWPDbe2FRT2tbW1FCsWXla5zLFCsuY4xpfE4FaoNZlt5SOYCxl/0lnWRYs2HTTQOzLJ4c45VkCmN+HTmIRpXm3X5ZS2LKNMk8+1Rx6EpJhJFJ8enfYySEgH143Qfwj9YUtsfv4TXalOo3P8KE4SQ45tfxr5LHzCbd6U5G3bbxuCIEr42KDU1zft42tiJdi58SXgGG2pLipc36eFBEA3K17GPec+7ka1GV9vTG3FCnMMqB2WqFqIVhG8YXQhQSUzH0ek5gIYNWk74BmY7CHug2hD2MLraKE3vFsJvjK42Oof3FuEtWJIi7MGC2igKy1JEhdHVJlA2f2NZiihhwd9GEITB+HVSCotRJAMW7DaawuxNGzwYWpkd43tAsnY6Q9TwMNM3ft6GNVIkE6P3AaFoU7YmTAse98uYIQQxD4yuNpqY0gNSv35g06at9MeZPuPXI0cPkK/gr9Ddv8+dRpDcsPC2hMDGzXON8+TJwxo16pCvAFIgSB4wR7stMTFxz96Qa9cvR0Y+d3Up/M03Dfr1HWJjYwO7EhITNm5affXKhdjPMeXKVmzSpGXrVu31hENJmpiYsHDBKti+cvXirl1bHj954OJS2N+/ysD+w11dCzcKDIBd8xfMXLV68d8Hzuo5NWSB4M1pEthyzrzglJTkihUrDR44okIF/5GjB969ewsinDhxOPSvU06OOL2ITozfUzz/5ej+v3Zu37Gpa5des2ctGTRoxNlzJzdvWcvsmjdv+sMH90aOnLBpw1540ouX/P7gwT094WqePns8YeKIatVqQISfh497/vzp3HnBEH7syEX4HDtmCkhN/6lFItGDh/dO/nNk9aqtRw9fsLayZkrPJYvWwhmbNWt95tQNlJp+jO/dFQjym7t1+f6HBvUDPT29ma9hYXevXb80aODPsH333q1uXXvXCKgN2wMHDG/QoImTYyE94WrC7t+BLOqHnv0EAoGbW7Hy5Sq+iAjP16mBlOTksWOmSiQSoiyjW0Aml5yczHxF8oLx1UYr8pu7icXi6zcuz5k7Lfz5U2ZyP2dnF2ZXpUpVd+8JiYv7XKXy/8DYKle2gv5wNf7ImxURAAAQAElEQVSVqkql0gmTRgZUr1WnTn0P95LVqgbk69RAyVJeam3Z2zvAZ0JCPKot7xi9JDWgnXTtuuWbN69t3bpDyJZQKJ569uir3jV+XHDnTj1AEJOmjO7YqemGjasYTegKV1O2TPk5vy8r7FoEEu/Vu8OYsT9BvpWvUwOQLxLkKzB+H5B8+sxpmv770D6QTpvWHZgQMPPVex0dHKE0BBGAVv69cGZryHrIY6D40xWumXKtmt/AX9+gwTdvXt23f8fESSP37zuZ91MjX4/x87Z8tgfK5fKUlJTChYsyX2Uy2aXL55ntuPi4/X/tggIR6oZQdP40ZBSUhmD+6wrXTPbOnZtXr12CjcKFizRv3mboT79ANfbd+7eacdLS0nSdGikQjF805LM5EKp+pUp5HT128M1/r8EOm7dgRiX/qmAeJSUliYQiqCEGzxgPGVhMzCfwODwLfwx7dYVrJhv24G7w9HF/H9r/+XPsw0dhUPcE2RVzK25tbV2kSNEbN67cvnMDCkpdp9Z/ze7uJR89Crt1+3pqaipBdMNCyxXJ78iEKZNm21jbBPXt/EPv9tX/V7N//2HwtUOnJvEJcTOC50dHfxg+4sdO3zffuXvL4EEj27bpaGdnpzVcM00oVVu36rDijwUdOjUdNXqgRGK3eNFaUDbs6tmjHwhlytRfUqQpuk799t1/ei64beuOkK2OHTcUS179GH3WmcfX409u/xAU7EuQrGwODh+2mF+3hYWe4tgHBMmAhRF+OKIUyQBH+CHswULfXRxzpR0e3hS020wGD2+L8Uf4odiQTIxvt9EES1KEgZ05jjB7Q5Sw4AHh4bhJRDvGL0mFyooCghA21CbHqUCQDNiYUQsrCQgDK2OusCTVBnp3Cx6xNS3A5rEcxMWlaCzOyxeM3r+tdCVH+PwvMp4gGjy++FkoJnyDjWEdRT2sLh/8RBANIsKSfavZE57Bhto6jyhlX0i0a0E4QVRs/z3c288usEsxwjPYW580ZHZkQmy6lQ0lFAnT0vSdVEBRCh1XRTGLkGasmKv94tXh2SJorDxK6WlMY47SmrhqOV7ltek6tUA1o7VCh8vHykqQliZPTVZ4lLNpN5CPy8yxuvbyfy+Sb52OSUmk02T6TkoJiK4Vx+BhxsXH2dhYW1lZq5dEzh5Hc6lkOsvBeakH6jl7clIy3DCJxE7nqVVFha7DxWLK3lnQsKuLra0t4SWsqu3rWblypYuLS7du3YiJmD59eu3atZs3z33qJCQnHFMbwmk4M9XA69evQ0NDiXmwfv36bDM/IHmBG2p7+/btsGHD2rdvT8wDKEk7depEkHyCJamByOVyyN6sra0Jkmc4kLft3r378+fPxMwQCoURERH3798nSJ4xd7X9/PPP7u7uhQoVIuZH+fLl9+zZc/jwYYLkDbMuSRUKBaWCmDExMTGOjo7MlCKIfsw3b3v06NH169fNf5ks8P+dPXsWXgyC5IaZqu3ixYurVq2qVasW4QJQpHbo0IEguWGOJSlcUmpqKjNvPFdITEyMi4sDE5MgujHHvG3Xrl3ckhpRTvqs7D708uVLgujG7NTWtm3b+vXrEw4CGRu0MWAVVQ/mVZJCeQS5Gqfrd2FhYd7e3nZ2dgTJgRnlbbdv3/7w4QPXXQn+/v5RUVEE0Ya5qG3r1q3nzp3z8fEh3EcikWAVVStmUZJCDVQqlTo5Wc4iUdHR0f/991/lypUJooHp87aEhIQrV65YktSIclWGwpBPw08jiAYmVhtkaS1atGjQoAGxOMAn8vvvvx8/fpwgmZi4JIXixs3NTWi5A3lPnTpVvXp18+xVwD6mVBs0g/r6+jo7OxOLBtw6jO8XMVlJOmPGDMjYLF5qQGxsrPn0OjYtpsnbPn/+LJfLXV1dCT+AFq3w8PDAwEDCb0ygto8qKlasSBCewbbj/vHjxzNnzty2bRuxOD59+qT/1QWHiJWVlfGGMoDbhZg3rNptTJdDi5RaXnBwcFCoIHyFVbXdvHkTKqGEx9ja2vJ5uXD2fnlQUBDX+3cUCFA9MsMhZOzAUi3h1atXUI5Ytr8jV7tNTXp6elpaWoHPPYN2mxLwq4nFYj641vIIZPB5kVpERAQ064WFhRFLwehqO3LkyKpVq4oXL074R7du3d6+fatrb1JSkkwmI3zCuFYUNNp4enq2atWK8I/379/rt8/s7Ozg/ghVEH5gRLWBdfL69Ws/Pz/CP+7evTt+/HjY6Nu3b506daZNmwbb27dvP3nyJJh3RYoUqVy58vDhw5n20+Tk5OXLl8MhIL5SpUo1b968bdu22RKEXVu2bIGWZWgHK1u2bOPGjaGQJVzDiGqDhhreDgmpUqUKNARPnTp148aNjBUBWjl69CgoDHR269atpUuXuru7d+7cGdxvEydOhAigyGLFikGcP/74A/RUrlw5zQQXLVoEDTDDhg0DOf7999+gTtjgXHuMsey2O3fugNSw7wMD5Ex79uzp3r37N998A/ekfv3633333Y4dO6BmeuPGDWhfGTRoEMjLyckJTD0oDUJCQrKlcP/+/Xr16lWvXh3yxX79+i1ZsoSLrcxGyduioqLKly/PuTGhxgMsChAW3BN1SJkyZaCWALX1yMhIuFEVKlTQ3HX27NlsKYAE9+/fHx8fX6lSJdAcxCEcpODzNqhndenSBaWmSUxMDHxqtpAyHpCUlBTYBfcKHHUgPvUuCM+Wwi+//NKhQwdojAkODob8b/PmzVycHLPg8zZomfH39yeIBszwUqlUqg6BmgFRzVgjkUggHNQGn0w02JWzlATfOIisa9euDx48uHTpEpTCUCJzbn7Mgs/bwHW5bt06gmjg4+MDbo6HDx+qQ548eQJyAe8/VAhAZy9evFAPeIZd4DbSPBwK0AMHDkA0iqLgTR44cCDUQsLDubfaScGrDV5TS3J/G4yHh3L9jfPnz0MlAHIm8Fns3LnzypUrCQkJ//zzz8GDBzt27AjlQEBAAFRaly1bBo17UKpu2rQJ4mfLtOAF3rZt26xZsyBjgzhwOEiNi66lgm8nBbutQYMGly9fJjwjZzvpwoULz5w5A36KefPmgVm2du3ac+fOgb0F8gLxff/990wfBagoQGkAbhErKytvb2+weqHqSlQtV0OGDFmwYAHkZ1AnhSYZyAIh3MvLq3379s2aNcvWncT820kLXm1wN+Ee8bAwzXurfE7gQDj8K+XCR7Xxlq9RG1HVIb6yIs/HPiBotxkGH3xGBa82cGMOGDCAIPkE2huIpVPwakN/m2Hk9OhaHmi3FRhfabeB2r6yNy/abfyC+gqgUYH6OojZg/42c2Hx4sXDhg0Ti8XEckG7zVxg2qaIRYN2m7kAamvRooVlLwpY8GqDBKE5D7M3JCfobzMXVq5cafEzp6LdZi4cPnxY3aHSUkG7zVwAtTVs2NCyl/VAuw1hD7TbzIX169dDawSxaNBuMxdOnDgRGxtLLBq028wFUFvNmjUte657tNsQ9kC7zVzYsmXLu3fviEWDdpu5cPr06Y8fPxKLBu02cwHUVrlyZfPvo/Y1oN2GsAfabebCrl27IiMjiUWD84CYmA4dOsAdE4vFb9682b59OzPtOoRs3bqVWBwFrzacByRfpKamfvjwgdkGwTEbjRs3JpYIjkswMXXq1MlmOru4uPTr149YImi3mRgQFjM/jRqomWrOK2hJoL/NxLi7u9evX1/91dXVtXfv3sRCwfnbTE+vXr1Ac8w2vKiQtxELBe0201O0aNEWLVpQFAUZW48ePYjlYiHjSe+cjX50I0kmpdNStf8cgYBSKOicgaqfn4+bIKCIIre4FEXU6cEpCA2H0Houg6he0bi4zyKh2MHRAQ7QjKLrEObiIWHN0+mKz8QRCFUXk7mXgvPmSJaCZFURILIyeUUuP5DByoaS2FN1OxQtXkrfcH9L8Ldt/T0y6XO6nZPIWiIUCrVrgRKQnDeOuWs5750etKaj9wDVQ6VzP1xiX1ilfOWAe0256bo8inlV6DxdYcYvVZZkWRLXesFMmsrIdF7fQ7EVlRgnC13+pmyAfWDXYjrT5no76fa5kalSReeRPgQxA7b9Hl6qnKRV3xJa93Lbbtu3LEqWilIzI3pO8H31KPn2mWite7ntb/v4OrViHUvu7MpFCpe0uXdB+8BYDvvbUlJS0tNJhZouBDEnipayTU3UvnIIl9tJ5Vb5M9gRVhCJRWky7dN7ob8NKWCgTkwoXbsKGmwn5TkKQhEdfg4O+9sowoHZGHkIlfG/Fjhst9EER1SYIzQhup4Mh+02pdedIGaH8qlYnt1GU5i5mSN6Wqe4bLeh1swUFmsJaLfxHIpNDwj62xBdhSn625CChlL16tMGl/u3CQr+VUG+HpqmdLUocthuoxRot5kjery7HLbbTFJLePEivFFgwP37d4ipadchcMvWP4n5wap318zttg6dmv739g3hPl279KpcqZr+OF//Y6fP+PXI0QP5OoTVOqk5jyd99+7t588WMrdtj+5BVatW1xOhQH7skycPST6hLdLfRlGCfLVcvfnv9Q+92sNGzx/a1a3b4LcZC2EbCqPjJw5FR38oWrRY1SrVR42cIFBVPpKTkxctmX3nzo2EhHgvT5+WLdu1b/d9tgQTEhM2blp99cqF2M8x5cpWbNKkZetW7fVfQ2Ji4p69IdeuX46MfO7qUvibbxr06zuEWeP71atISO3O3Ztgivj5Ve7WpXelSlX1hENJ2qlj9969+kP4vv07jh8/FPX6pWcp74CA2pDmvfu3R/8yWPPHRkQ8P/j33lu3r7979x/8olat2rf7rjNzVe07NukbNDgu7vPmLWttbW1rBNQZNnSMq2thsBlg7/wFM1etXvz3gbMkb1im3UZI/qoJ7iU8fp+1BDa2hRxgpAZPMfTA7iGDRu7dc/zHfj+dPXdyz95tTORfJ/7833+vZ85YuHvnkfr1A5cum/vo8YNsCc6bN/3hg3sjR07YtGFvhQr+i5f8/uDBPf3XsP+vndt3bIJCcPasJYMGjYAzwgMmqmGRI0cPFAqFc+csXzh/lUgomjR5lFQq1RWeJc39O0O2bejcqcfO7Yfatu10+Ejozl1bqlUNyPZj/1i58Pr1yyN+Hj/n92UgNfhFV65eZFIQi8W7dm2B1yz0r1ObN+67H3Zn0+Y1EH7siDLC2DFT8i41otduK/i8jbHbWBhP+pWDxSBn2rFz85DBo+rVawhfGzZo8uLFs5Bt6zt26Hbz1jWoB2z4c5e3d2nY1bNH36vXLoIs5sxeqpnC3Xu3unXtXSOgNmwPHDC8QYMmTo65DJLo8v0PDeoHenp6M1/Dwu5eu35p0MCfo6JexsbGQF5VtoxyBpBpU+dA4unp6e/fv9Uanu0yypWr2Lx5G9hu07pDtWo1UpKTc556ypTfk5OTihdTjoYCLR47dhBOXbtWXWavu3vJH3qqprqxd4C87enTR8RwdD4Zo/jbmjdvTsweeMDwYkCek/xp6wAAEABJREFUpA4pW7YClHRv3kRFRIRD6cZILWNXmQqnTh/LlgKUaLv3hEABVKXy/2rUqFOubAWSG5CLXL9xec7caeHPnzKicXZWjqvw8ChVqJDznHnBTZu0ggLd378KCEIVX3u4JhC4dt3yefNnVK5crU6d+pCFaz83TUMuCK8N/HAmoHhxd83frt52cHBMSkokhiIgOjvnGMVuCw4OJmZPTIxyFJqNtY06xNZWQpSDa5I/fYq2scky5lsikUB4thTGjws+eHDv6TPHQXP2dvYdOnTt3WsA/Hw9JwVZHDkSCmUo5B9ubsX+XP8HU+OztrZeungdFIJ7921fv2FliRIeQb0HNm3aSle4ZppQhkokdhcvnZs7bzqcvWHDpoMG/Fy4cBHNOAqF4teJI9LSZAP6D6taNcDB3mH4iB81IxTgQuGs9t1lbd7dfFYSsmNnZw+fKdIUdQgUNEQ5fVphOzs7qUY4kJScVNi1SLYUHB0cofSBchYKxH8vnNkast7e3gHKSl1nhDvz96F9IA4o75iQxMQvI+FKlfIaMngkWOu3bl07euzg7DlTPb18oADVFa4+EAoTSBD+IiNfQJxNW9ZCzjT7t8Wap3767PHjxw8WzF9Z/X811acuUrgoMQKW2b+NfN2Aq9Kly4L1/eDBXXXIo0dh8NIXKVIUKphgiT8Lf6K5y0ujYAXi4uP2/7ULokGuAEXqT0NGQRkHD1XPGeHOpKSkFM58xlADuHT5PLMNFU9QEmxACf7NN/WDp82FXAqMJ13hmslCbRTqm7Dh5eXTsWM3MPLCNa4842rjPsOnWl6gS/gjRkK3Pc1hf5sBbQklS3nB59mzJx8+CoOcCYwhqM1dunQ+PiH+xInDf4Xu6ty5J1x/zZrfQJm1aNGsx08exsR8giIM1Nb1+16aSUH1EOoNwTPGQ8YGceDwZ+GPK/lX1XN2KysryKhAPeCLgcc/b8EMiA8elqSkpPj4ODC8Vq1e8vpNFNhV27ZvBKvO36+KrnDNZMGgnBo8Fn4FvABXrlz498JpJoLmjwWXB8h01+6t8EtBwctXzIfKzbv3b4leoByHd+/GjSu379yAspjkDVbrpOY8fxtY0C2atwXHBzyPxYvWDP3pF9DWzFkT4RGCvHp079u9Wx+i+gngNVi9ZslPQ/uARHx8ysycsYDxcqmB0nZG8Pzlf8xnDCCoUgweNLJli+/0X8CUSbPBExHUtzPkVT8NGQ0m1LVrlzp0arJ5077RoyaC3wFMQIgWUL3WooWrIa+CbV3han4ZPXnFHwsmTRlNlGaAKxSp33f+IeePnTTxN3g92rVvDNXPSRNmfoqJnjJ1TJ++nTdv3Kvngnv26AcpQO11354TX7/mPYfXS5AmyddNjggK9iWIOXH/Ytztkx+HLtbyXLg8LoEm2HvXDNFTS+Bw/zYBMcf+bW2/a6hr1/jxwfXqNiSWjp5cgMN2m4KY4ywga9du17XLuRAvJsihmBkYtcFhf5t5wjQN8Rla92SfHLbbcGYGM8Ui7TYaxWaWCNgcvcyevw1XVjVL9LSTcnseEIJwChxPirAHrk+KFDACCudvQ9hCQVvi/G0I50C7DWEPDtttQiu5oOAvH/la0tPShFbad3F4fVIrKyuhgDy7ZSGjkS2G6CipjUSodRe37TYXd3HYBVSbefHxtbRiLXutu7htt3UZ4UkowV9/GK2LPZJPtv8e7uZpU7NFEa17Oe9v6z3Za/PMiO1zwh1drKxsKTpdqDOqevVXgbYRNNnWhs36NWPRT40D1R0dtC85yhyu/USqDjnaeksJRUSubYEo7UuOQnukgspLTIGQVsipLBej5RqYhVoz96u7ceT8CUwIpKDRUC0Q00lxssTPcu+Kti2C3IkOOL8+KcPlQx+eh6WkJqWlp+WeW+d7RdvMQ7IcmHm7873Ormrm/ZyHKBQKkQg+tVy/QEByjkHREahl4WWhkMjlWS6G6V6b5RqyqkfPu6R1xWZricDajgQ0cS5TxYnohsPjEiyMadOm1ahRo02bNsRyQX+buZCenq5/nL0FgO2k5gK8pWKxmFg0/BpPas7wIW/DdlJzAdVmCGi3GQbabYaAdpthyOVyVFv+U0S7zSCgTMCSNN+g3WYYaLcZAtpthoF2myGg3WYYqDaDUkS7zSD44N1Fu81cQLvNENBuMwwsSQ0B7TbDQLUZlCLabQaBJakhoN1mGFhLMAS02wwDS1JDQLvNMFBtBqWIdlv+gSZ5eEsLcLEp8wTtNrOAD0YbQbvNTOBDMUrQbjMTUG2Gpoh2W/7hidrQbjML4Ka5uroSSwftNrMAMrYPHz4QSwftNrMA1MYsM2/ZoN1mFvBEbWi3mQWoNgNBu80AhEIhNCcQS4fD68pbEnDTiGpSLWLRcHjeXQuDD4Up2m3mAqrNENBuMww+qA39beYCqs2gFNFuMwgsSQ0B7TbD4IMTBO02cwFLUkNAu80wUG0GpYh2m0Gg3WYIaLcZBqrNENBuMwwsSQ0B7bZ8Ua1aNUoFlAlBQUG0ioYNGy5evJhYHNhOamLq1KlDlOtKUcx4UvgsWrRov379iCWCdpuJAWFlG5FQoUKFSpUqEUsE7TYTExAQAIWp+quTk1P37t2JhYL920wPZG+FChVitkuXLl2rVi1ioaDdZnrKly/PKEwikfTo0YNYLrg+aXbunv/0+mmqLDXjq1BIy+XMZDA0pVwzNksg/Fgw7jMWjv2yxKxyIVzlqrGqcIFqZVmNu0yraqDMIco1aGFTmpLy9NkzoUjo7+dHvkSmVYvPfoGZlSbLExPQJHMFZmb9XWWahNKMQ6kuPecathDTSkL8ajl4VnAkrFDwapPJZA0aNLh8+TLhGrIU2aaZrxRyIrYWpKvVJqLk6Yw0VM9etSkSU+lpyi140EL1IsaMH0ORoZAvCyxTKpmqb7Pm2ssaSlQoFJSAytCuRuQsC44LlV81F0NWro1MZ1WSQLVwcpZ1lVULNedo8RcIaIGYSk1RSOwFQdN8iPFBf1sGMpn8z6mvKtRyCGjqRnjGwTXPN06P6DvNmxgZC1lX/utZNS68etNCFWoWJrzkyMaXKfGKoKnGFRz625Sc2PZWZEV4KzWgVV/PpHj5m8hEYkzQ36bk46tUOycrwm+srKmHlxOIMUF/mxJZioKW892igGpESqJxB7Ri/zYlcnBD0BY+522uKBSESi/43EcTtNsQ9kC7DWEP9LchGYCnmTJuQYp2G6KGytZOVvCg3aZECE1GQqwlENrI41nRblMiV9AK3ntAWADtNiQDtNtYQjkkwMg32vxRZO1dYgzQblOiUNC0hU8LmRcoYuRXDu02JapOiITnUJTRLVe025Sout3yXm60lv69BQuOS1CirPwrzKhO2r5jky1b/yTsQhMOqg3bSRFdoN2GsAf2bzOQdh0C9+3bMWLUgEaBAfEJ8RBy7PjfPw0Latm6Hnzu3bdd3QU/ITFh2Yr5PX9o16rNt6NGDzp8JFSdyMWL5wYO6tm85TddurWaOHnU+/fvNE9x/cYVSDws7K465NHjBxBy5epF2H7w4N648cO+a9eoV5+OK1ctTkpKYuLs27+z0/fNL1w8G9i05tp1y0meUQ7VMXJFAe02JaoaQv5utFgsPnTkL1/fcvPn/SGxlfxz6tjcedPLlim/PeRg/x+HgtpWrFzIxJw3b/rDB/dGjpywacPeChX8Fy/5HYQC4TduXp0aPLZZs9a7dx6ZNmXO+/dvlyybo3mK/1Wr4WDvcP7f0+qQCxfOQEiNgNqv30SNGfeTNFW6YvnGmdMXvHjxbNTogcwUSVZWVsnJSQcP7p3w64zWrTuQPCMQEGM336HdpkSVDeXvRlMU5ejoNHzomIDqteAFO3IktHLlaiNH/Ors7AIq6dtncGjo7tjYGIh5996t+vUDQSJFi7oNHDD8jxWbXF2LQPiGjavqf9u4c6ceTk6F/Pwq/zRk9JUrFx4/eag+hVAobNSo2fl/T6lDQHmBgS0g/J9/jopFYtBZqVJeXl4+Y36Z8iz8CeRnzIVJpdJu3fo0CWzhXsKD5BlovqONPKNXwasN3rD58+cTTmFYW0K5shWZDYVCEfbgbo2AOupd1arVgMB792/DdqVKVXfvCVm1esmlS+fBqC1XtkKxYsUhHDKk8uX9sqX2+PEDzVM0bNgUitenzx7DdkTE89evXwU2bkGUxehdOBZkykSDBEuU8GBOx1C+nB8xPwre3wbvFmTmhFMY1pag/pkymQxktH7DSvjTjMDkbePHBUO5dvrMcdCcvZ19hw5de/caANlPamqqtbWNOrJEIoFPKAQ1U6hapTpklufPn4Iy+t8LZ4oUKervXwXCExMTIBcEGy7L6WI+5bw2swLbSZVQ5Ku6dtnY2IBWmjVtDSWmZniJ4sqCzNHB8Yee/Xr26Av2Pihma8h6e3uHjh26wS6pNEUdOUmlM1eXLKMM4dWFwhSKSLAFwWhr2qQVE+7iWhiyzL5BgzUjOzkWIl+B0njlXKs8F+cBoZQT9X2VgVy6dFmoe1armpHZQFb39u0bMNTi4uNOnTrWqmU7UCToA/7Cw59AyQjvJBSpTHWBgdn2KV0mW8qNGzbbv38nmHRgmU2cMDPjdD5lTpw8XKXy/5jF/4DIyBceHqXIVyBQdvIjRgX9bUpUJelXVf4H/Djs4sWzR44eAHPt/v07M2ZOGD1mMJSwIqFo85a1wTPGQ8YWE/PpxInDz8IfV/KvCod0aN8VMi1wo4AD5fadGytXLYLqRRnfctlShgoEqHbjptU+Pr5QIWACO3fuCSeCai+UyFFRL9esXdavf9cXEeHkK5DLaUUaMSrYTlowQKa1dvW2bds3woOH8tGvYuXfZi6yVjEjeP7yP+YPH/EjRPP2Lj140MiWLb6DbfB9fIz+sGvPVhCNm1uxgOq1B/QfpjXxhg2ags0Hhak6BErn9X/u2rlz86AhP7x6FQk1hrFjpoBtR8wbnAdEyZ9TImwkwnY/fVVJxHVCZj338Ja0HVKcGA30tynB3pRKKPX8dMYC7TYVmMMrhwIZvS0B7TYlyhoC7/vuKmsJRm5LQH+bEtVSBQQxNmi3KaGxJFWCdhsr4LgEoppTmCZotxkfVU9xwnNoYuysDe02JBPK+KOX0W5DMqC5OHqZi3abytVEeI5yqQYj3wS025TIFVoWr+AbCgVNGfkmoN2GsAfabQh7oN2mxMqGElsTniO2FohtjVtNwPGkSiQOlDTRyG2EZk+aTO5awrjvHI4nVVK3fdGkBF67d5/cigX3bo1mxl17Ce02JcVL2bp5WoXM/qqe1pzm2pFPtVs6ESOD65N+4drxT7dPxxb2sC5a0lZoJc62l6IUNJ3l5RQQ5ZKiGmPslbtpSnMlWlo1bCpz/Vrl2reaTd+q+OqvzCKm6oVymVZL1fqkGauiZu4SKL2wVOZVaSyOq5xZISM1inxJSnUiSpEjHP6VJqb9F5EU9yG9+7hSzkWNPigQ/YbaXCgAAArxSURBVG1fqNncVWhNh51PiP7vc7o0+15KSGVfCytjSeaMb7RKV5ohX6LR2g/R81XBlDvqYzV20Xr6amTGpzUuh2iKUmNNX0pIRGJi5yTsNq4YC1IjOC7BfAgODq5evXrbtm2J5YJ2m7mQnp4OFSxi0aC/zVyA+yYWi4lFg3abucCHvA3bSc0FLEkNAe02w0C1GQLabYaBJakhoN1mGKg2g1JEu80gsCQ1BLTbDAPVZghotxkGlqSGgHabYaB316AU0W4zCCxJDQHtNsNAtRkC2m2GgXabIaDdZhioNoNSRLvNIPhQS0C7zVxAu80Q0G4zDCxJDQHtNgNQKJSDVNQLu1gqaLeZBXww2gjabWYCH4pRgnabmcATtaHdZhaA2izeaCPGG0/6+vVrD498LDPNc0JCQmQyWb9+/YhFY6z36c2bNytWrCBIHpgzZ87bt28tXmrEeGqrVauWnZ1ddHQ0QfQyZMiQ0qVLjx07lvAA487MIJVK7969C2YcKI8gWYGb07Fjx+Dg4Jo1axJ+YFzL1MbGpkqVKi1btkxMTCSIBo8fPw4MDNy4cSN/pEZYm3UmPDzc2dnZ1dWVIIQcP358y5Yt27ZtIzyDpVq3r69vamrqrFmzCO9Zu3btuXPneCg1wpragBIlSlSoUOHGjRuEx0ycOBEKk9mzZxNewvb8bXFxcSkpKeDM5KE3rmfPnr17927evDnhK2z7r52cnNzc3IYOHQoOOcIbPnz4UK9evSlTpvBZaoR9tRHVRLQHDhyIjIyUy3mx2g8YD3369Dl58mT58uUJvzFZ21zdunWhEB83bhyxaPbt27du3bqjR4/a2toS3mPKlmCRSAQly/bt24mFsnDhwidPnqxZs4YgKkw/yzPUG8CYA2+nhRU0P//8c+3atXv06EGQTEzfywWkBp9Lly69d+8esQigxt2uXbuuXbui1LJhRjPYHz58uHXr1oTjPH/+HEQG5hp2uMqJGfXgY6Q2depUwllOnz49YcKEq1evotS0Ynb9RTt37sxRwUETO9Q9d+/eTRAdmONaMElJSXZ2dmFhYeoe502aNKlSpQpU8YjZ0KlTJ7h1+/fvZ75OmzatSJEiw4YNI4huzLEvPNMZDtyhR44cgY22bdt+/vz50aNHT58+JebBnj173r17FxERwXwNCgqqUaMGSi1XzHfkxahRo5hecUwb1/v370NDQ4l58Ndff0Frr1AorF69eqNGjX755Zc2bdoQJDfMepxPly5d4HEyg5GgvevixYufPn0ipuby5cvQ7qm+qtTU1EqVKhEkD5i12mrWrKlc9jATKLzUdpIJ2bVrV2xsrPqrTCZr2LAhQfKA+aotMDAQ3KTMBBkM8PXYsWPEpLx48QLMR813AOoK8fHxrVq1IkhumPX6pAumb/7wX0JSklQup5MSEymBksaNG/v7+amXdVUvUEwyvyo/mYVgM9cizroQMaEENK2gBBRRfFksFm4DpdpQJqbIWJpYJSXm34x49Pnz/96+dUu1l7KxFlOUwqGIoEI1Nz6Mz/t6zE5t5/e9fxGWnBgnJ1qui1ZpSLmVufwwxax5nPkrVAJR5di0aonszNWHsyxXTBEtaTOBlMY5MhbZ1oirSkShcYTG4QLi6CouX9O+RhMce6ETM1LbvmWv3r2UwWOzklg5FrF19XKCSh/hArIU2adXCYnRybKUdPjq7S9p1bcEQXJgFmq7cODD3XPxImuhWzmXQm72hMt8eBH76WUcraAbd3ctX92ZIBqYXm1bfnuR+FlRwq9IoWLc1pkm7559io6Id/e16TAUG0y/YGK1bZ4ZmZqqKFvXk1gij89FuvtK2vYvThAVplTbhmkv0tJJuXqWKTWGB6cinIuIeoz3IogJ1bYxOIIWCH1quBNL5/G/r1yLir4fWZLwHtN4d49uepsqpfkgNaD8t6Xev0q9c870bW4mxwRqg6ae5/eSyjew5AI0G+4VXS4diiW8xwRq2zHnjY2jFeETzu5OQrFg//Iowm/YVltCbGriZ7lvLV6UoZoULevyNjKV8Bu21XZ00zuRrfl2BUhMih0zpdad+/+QgsbZzUEgpP7Z/pbwGLYffMzb9ELFLceLmy+sHMSRj5IJj2FVbTHvUtPTabfSPG23LuLlLE0y3x43LMDqihAPrsQbtZ098tW9E2f+jHr90N7OuUK5es0a9bexUQ5xuHhlz8lzG4b0W7Vl54T3H14Ud/Ot/033Gv/L6Nt9+96JY6fWpKTEVyz/bYO6PYnRcCwsgc/Xz5I9ykgIL2E1b4t+k0oJjXXG6E9RazYNT0tLHTbwzz495r59/2zVhiFyubJThlAkTklJCD28oEv7ifNnXKns33h36G+xn9/Brrfvw7fvnRpQrdWvI/cFVG194LBxh3VRAhL5KInwFVbVJk1WaPZ6LVhu3T0mEoqDus91K+JVrKjP9+0mvXn7JOzROWavXJ7WtFF/z5KV4AJAVdCC8uatcgTXpav7CjkVa9rwR4nE0deneq2A9sSYUJQg+XMa4Susqk2ezvSENQpQjJb0qGhnV4j56uJc3NXFI+LlHXWEUu5+zIbE1hE+U6QJ8BkdE1XMzUcdp6R7RWJMFHJFmozwFlbtNlAa3G5iHFKkiVFvHoL/QjMwPuGTxtm1CD05Ob6w65cWTCsr486yBpcgsjLW+2b+sKo2iaMg9qOxyhEHB1dvz6rNGw/UDLSzc9J/FBSgaWlS9dfUVOMaVTRNnIvxqx1FE1bVVsLH9s0zY/nTS7iVuXn3iI9XNfVieO8+vCjiWkr/Uc6Fij98/K9CoWCOevjkAjEqNPGtxNMKKWHZbgtoasSe0+DUANEcPLpYJpN++Pjy0PEVC1f0gCqn/qOq+DWB9oPQwwuh3hD+4ualq3uJ0fj0Oh7qpC7F+TslKqtqEwqFIisSFWaUpdagTBwzbLuV2HbJ6j7zlnV5EXnr+/aTPErkMt9luTK12jQf/uTZ5bFTa+/cP6NbJ2Z6JaP4YGNfJ9g5cmNcj5FguzflgdVRbyNl5Rt4Ef7x6HRktcZOtVsWJnyF7XbSdoNLpsvo5EQp4Rnvw2OgGOWz1AjLtQSGIh7iqDsfytXTbr/HxX+cv7yb1l221vYpqdrXAixWxGfYwHWk4Jg8K1DXLmifAIsgZ3hJ9wqDgnQuABz7Jr5MFb5PYm+acQkrRoeXrFTESduQPrlcnpSkvZtrerpMJNLuPoDHr/brFgjx8TqNyzS5TCzUchkCochexzW8fvAhKTp50JzShN+YIG8D6rZ1uXjwo1a1QU3C0dH0xU3BXsPnN0n9gnEUjIlGwVRr5FLcx+rhmQjCA8JORlRu4CBxsia8x5TjSf9e9/bVkyS/QG9iuTz4J+J/gc51WuFUNEpMPFY+dNWbN+Epfk0sUHDJcakR1/+r3tSldgsXgqgw/Twgx7a+Cb+d4lBU4lnFjVgK4VdfS+PSwDyt1hil9gWzmOMoLiZ198I3aakK+8KSUlzWHFSoX958lxIvs7ET/DjDhyBZMaP5264d+3T3/GeZlBaIBVZ2IjtnW3sXGxt7a5GV+bb2pMvSkz4nJ8fK4j8mp0nlREFs7AUNO7n6VnUiSA7Mbm7KmA8pFw/ERL+RpaYooNVBGUR/mQeSztodUzl/adZea7RqGspsadLaOnHShOTsaEbr6O6pPZzKmP+SEhKRmPIqZ9usD04SqA+znncXsTBM491F+AmqDWEPVBvCHqg2hD1QbQh7oNoQ9kC1IezxfwAAAP//1M/wjgAAAAZJREFUAwCzW/Ou17N32gAAAABJRU5ErkJggg==", "text/plain": [ "" ] @@ -176,10 +165,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'custom_node_3': {'messages': [SystemMessage(content='Testing the custom node custom_node_3', additional_kwargs={}, response_metadata={}, id='7530df95-897c-427b-8d1e-ccc9d2485b2d')]}}\n", - "{'custom_node_2': {'messages': [SystemMessage(content='Testing the custom node custom_node_2', additional_kwargs={}, response_metadata={}, id='7a12543c-8c12-428a-a657-eb44a441267b')]}}\n", - "{'custom_node_1': {'messages': [SystemMessage(content='Testing the custom node custom_node_1', additional_kwargs={}, response_metadata={}, id='36a5bacc-cfd4-4798-9bc5-afca1332a09f')]}}\n", - "{'assistant': {'messages': [AIMessage(content=[{'type': 'text', 'text': 'We’re testing three custom nodes: custom_node_1, custom_node_2, and custom_node_3. How would you like to proceed? I can run a quick test on each with a sample input and report results, or focus on a specific node. If you provide a test input, I’ll run it through all three and summarize.', 'annotations': []}], additional_kwargs={'reasoning': {'id': 'rs_0ce9dee759a650e30068e040a533e881909c9dd77472e31b83', 'summary': [], 'type': 'reasoning'}}, response_metadata={'id': 'resp_0ce9dee759a650e30068e040a48d8c819090490c7d70dcc71b', 'created_at': 1759527076.0, 'metadata': {}, 'model': 'gpt-5-nano-2025-08-07', 'object': 'response', 'service_tier': 'default', 'status': 'completed', 'model_name': 'gpt-5-nano-2025-08-07'}, id='msg_0ce9dee759a650e30068e040a7cbec81908550ddea15d0e947', usage_metadata={'input_tokens': 60, 'output_tokens': 524, 'total_tokens': 584, 'input_token_details': {'cache_read': 0}, 'output_token_details': {'reasoning': 448}})]}}\n" + "{'custom_node_3': {'messages': [SystemMessage(content='Testing the custom node custom_node_3', additional_kwargs={}, response_metadata={}, id='db7877b4-06d1-444c-a89a-540898aff873')]}}\n", + "{'custom_node_2': {'messages': [SystemMessage(content='Testing the custom node custom_node_2', additional_kwargs={}, response_metadata={}, id='467dfe16-308c-431e-a12c-5fd6b1a465ae')]}}\n", + "{'custom_node_1': {'messages': [SystemMessage(content='Testing the custom node custom_node_1', additional_kwargs={}, response_metadata={}, id='bdd58412-80e0-4722-bcb9-43db069d2c25')]}}\n", + "{'assistant': {'messages': [AIMessage(content=[{'type': 'text', 'text': 'Hi! We’re testing three custom nodes: custom_node_1, custom_node_2, and custom_node_3. What would you like to do next?', 'annotations': []}], additional_kwargs={'reasoning': {'id': 'rs_0ca28290433fbae40069b57c2e2ee881a0aaa6559a48516067', 'summary': [], 'type': 'reasoning'}}, response_metadata={'id': 'resp_0ca28290433fbae40069b57c2e0a9081a0b1eed8223b49d0fb', 'created_at': 1773501486.0, 'metadata': {}, 'model': 'gpt-5-nano-2025-08-07', 'object': 'response', 'service_tier': 'default', 'status': 'completed', 'model_name': 'gpt-5-nano-2025-08-07'}, id='msg_0ca28290433fbae40069b57c30a06481a0a9da21fd8d5247f0', usage_metadata={'input_tokens': 60, 'output_tokens': 353, 'total_tokens': 413, 'input_token_details': {'cache_read': 0}, 'output_token_details': {'reasoning': 256}})]}}\n" ] } ],