Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
chore: branch cleanup -- pins, lockfile, registry, RFC, examples
trohitg357f972cb690
diff --git a/RFC-0001-UASTL-Universal-API-Schema-Translation-Layer.md b/RFC-0001-UASTL-Universal-API-Schema-Translation-Layer.mdnew file mode 100644index 00000000..76eca51c--- /dev/null+++ b/RFC-0001-UASTL-Universal-API-Schema-Translation-Layer.md@@ -0,0 +1,1373 @@+# RFC-0001: Universal API Schema Translation Layer for LLM Code Generation++**Title:** UASTL — Universal API Schema Translation Layer+**Status:** Draft+**Author:** Rohith Thakurwar (Genie.ai / MachinaOS)+**Created:** 2026-04-26+**Target System:** MachinaOS Agentic OS Platform++---++## Abstract++This RFC specifies a system — the **Universal API Schema Translation Layer (UASTL)** — that ingests arbitrary connector API specifications (OpenAPI 3.x, AsyncAPI, GraphQL SDL, raw provider YAML) and compiles them into a **standardized, LLM-optimized Python interface** that a language model can use to author structured, executable code for real-world digital tasks. The system addresses three converging problems: (1) the N×M explosion of API surface that an LLM must memorize to write correct integration code, (2) the fragility of LLM-generated API calls when auth, pagination, rate-limiting, and error envelopes vary per provider, and (3) the absence of a self-improving feedback loop that refines the LLM's code-generation prompts against execution outcomes.++UASTL combines four subsystems:++- **Schema Compiler** — transforms heterogeneous API specs into a canonical `UniversalConnector` Python interface with typed stubs, brokered auth, uniform pagination, and standardized error handling.+- **Code Generation Engine** — a DSPy-based module that receives a natural-language task, retrieves relevant connector stubs, and emits executable Python (CodeAct paradigm) targeting the `UniversalConnector` interface.+- **Sandboxed Execution Runtime** — a Firecracker microVM (E2B) or WASM (Pyodide) environment with persistent Jupyter kernel, browser automation (Playwright), screenshot verification, and console introspection.+- **Reflective Prompt Optimizer** — a GEPA-based evolutionary compiler that uses execution traces (stdout, stderr, screenshots, HTTP responses) as rich feedback to iteratively improve code-generation prompts.++The end-to-end flow: `Task (NL) → Stub Retrieval → Code Generation → Sandboxed Execution → Trace Capture → GEPA Reflection → Prompt Improvement → Better Code Next Time`.++---++## 1. Motivation++### 1.1 The N×M API Surface Problem++A task like "check top trending reels on Instagram, then post about them on Twitter/X" requires the LLM to know:++- Instagram Graph API: OAuth2 app-level token, `GET /ig_hashtag_search`, `GET /{hashtag-id}/top_media`, pagination via `paging.cursors.after`, rate limit of 200 calls/hour per user, JSON envelope `{ "data": [...], "paging": {...} }`.+- Twitter/X API v2: OAuth2 PKCE or OAuth1.0a, `POST /2/tweets`, rate limit headers `x-rate-limit-remaining`, JSON envelope `{ "data": {...}, "errors": [...] }`.++Each additional connector multiplies the surface. Nango's `providers.yaml` catalogs **700+ APIs**, each with distinct auth modes (14 variants: `OAUTH2`, `API_KEY`, `BASIC`, `JWT`, `OAUTH2_CC`, `TBA`, `CUSTOM`, `TWO_STEP`, `SIGNATURE`, `OAUTH1`, `APP`, `APP_STORE`, `BILL`, `MCP_OAUTH2`), pagination types (`cursor`, `link`, `offset`), retry headers, base URLs, and response paths. An LLM cannot memorize this surface reliably.++### 1.2 Code-as-Action Outperforms JSON Tool Calling++CodeAct (Wang et al., ICML 2024) demonstrated across 17 LLMs that emitting Python code achieves **up to 20 percentage points higher success** with **~30% fewer interaction turns** than JSON tool-calling, especially for compositional tasks requiring loops, conditionals, and library reuse. OpenHands, Devin, and SWE-Agent all converged on code-as-action as the primary paradigm.++The implication: the right abstraction is not "define 700 JSON tools" but "give the LLM a Python SDK with 700 connectors behind one interface."++### 1.3 Self-Improving Code Generation is Unsolved at the Interface Level++DSPy provides the programming model (signatures, modules, optimizers). GEPA provides the optimization algorithm (reflective prompt evolution, Pareto candidate selection). RLM provides the long-context scaffold (REPL variables, `llm_query()`, truncated stdout). But no system today **composes these three with a unified API layer and closes the loop against real execution traces from real APIs**. This RFC specifies that composition.++---++## 2. Terminology++| Term | Definition |+|---|---|+| **Connector** | A third-party API or service (e.g., Twitter/X, Instagram, Slack, Notion) |+| **Provider Spec** | The raw API specification: OpenAPI 3.x JSON/YAML, AsyncAPI, GraphQL SDL, or Nango-style `providers.yaml` entry |+| **Universal Connector** | The UASTL-compiled Python class exposing a connector through a standardized interface |+| **Stub** | A minimal Python source string (type hints, docstrings, no implementation) injected into the LLM's context for code generation |+| **Broker** | The credential proxy that injects auth headers at request time without exposing tokens to the LLM or sandbox |+| **Task Program** | The LLM-generated Python code that uses `UniversalConnector` stubs to accomplish a digital task |+| **Trace** | The full execution record: code emitted, stdout/stderr per cell, HTTP request/response pairs, screenshots, timing |+| **Metric** | A decomposed scoring function over traces: parse success, import correctness, call pattern validity, sandbox execution RC, output quality |+| **Reflection** | GEPA's mutation operator: an LLM reads the trace + metric critique and rewrites the code-generation prompt |++---++## 3. Architecture Overview++```+┌──────────────────────────────────────────────────────────────────────┐+│ UASTL System │+│ │+│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────────────┐ │+│ │ Schema │ │ Stub │ │ Vector Index │ │+│ │ Registry │───▶│ Compiler │───▶│ (per-connector stubs) │ │+│ │ │ │ │ │ │ │+│ │ • OpenAPI │ │ • Normalize │ │ • Embedding search │ │+│ │ • providers │ │ • Type-map │ │ • Top-k retrieval │ │+│ │ .yaml │ │ • Pydantic │ │ • Context budget │ │+│ │ • GraphQL │ │ • Docstrings │ │ │ │+│ └─────────────┘ └──────────────┘ └────────────┬────────────┘ │+│ │ │+│ ▼ │+│ ┌───────────────────────────────────────────────────────────────┐ │+│ │ Code Generation Engine │ │+│ │ │ │+│ │ ┌─────────────┐ ┌──────────────┐ ┌──────────────────┐ │ │+│ │ │ Task Router │──▶│ DSPy Module │──▶│ CodeAct / RLM │ │ │+│ │ │ (NL → plan) │ │ (Signature) │ │ (Python emission)│ │ │+│ │ └─────────────┘ └──────────────┘ └────────┬─────────┘ │ │+│ │ │ │ │+│ └─────────────────────────────────────────────────┼─────────────┘ │+│ │ │+│ ▼ │+│ ┌───────────────────────────────────────────────────────────────┐ │+│ │ Sandboxed Execution Runtime │ │+│ │ │ │+│ │ ┌──────────┐ ┌──────────────┐ ┌───────────────────────┐ │ │+│ │ │ Jupyter │ │ Playwright │ │ Credential Broker │ │ │+│ │ │ Kernel │ │ (browser) │ │ (Nango proxy / MCP) │ │ │+│ │ │ │ │ │ │ │ │ │+│ │ │ • REPL │ │ • AX-tree │ │ • Token injection │ │ │+│ │ │ • vars │ │ • Screenshot │ │ • Refresh / rotate │ │ │+│ │ │ • state │ │ • Console │ │ • Egress allowlist │ │ │+│ │ └──────────┘ └──────────────┘ └───────────────────────┘ │ │+│ │ │ │+│ │ Firecracker microVM (E2B) │ Pyodide (WASM) │ Modal │ │+│ └───────────────────────────────┬───────────────────────────────┘ │+│ │ │+│ ▼ │+│ ┌───────────────────────────────────────────────────────────────┐ │+│ │ Reflective Prompt Optimizer (GEPA) │ │+│ │ │ │+│ │ Trace ──▶ Metric (decomposed) ──▶ Critique (textual) │ │+│ │ ──▶ Reflection LM ──▶ Mutated Prompt ──▶ Pareto Pool │ │+│ │ ──▶ Selection ──▶ Next Generation │ │+│ │ │ │+│ │ DSPy optimizer: dspy.GEPA(metric, num_generations=40) │ │+│ └───────────────────────────────────────────────────────────────┘ │+│ │+└──────────────────────────────────────────────────────────────────────┘+```++---++## 4. Schema Compiler++### 4.1 Input Formats++The Schema Compiler accepts four input formats:++```python+class SchemaSource(Enum):+ OPENAPI_3 = "openapi" # OpenAPI 3.0/3.1 JSON or YAML+ ASYNCAPI = "asyncapi" # AsyncAPI 2.x/3.x for event-driven APIs+ GRAPHQL = "graphql" # GraphQL SDL + introspection result+ NANGO = "nango_provider" # Nango providers.yaml entry+```++### 4.2 Canonical Internal Representation (CIR)++All input formats are first compiled to a **Canonical Internal Representation**, a Pydantic model that captures the union of information across formats:++```python+from pydantic import BaseModel, Field+from typing import Literal+from enum import Enum++class AuthMode(str, Enum):+ OAUTH2 = "oauth2"+ OAUTH2_CC = "oauth2_cc" # client credentials+ OAUTH1 = "oauth1"+ API_KEY = "api_key"+ BASIC = "basic"+ BEARER = "bearer"+ JWT = "jwt"+ CUSTOM = "custom"+ NONE = "none"++class PaginationType(str, Enum):+ CURSOR = "cursor"+ OFFSET = "offset"+ LINK = "link"+ NONE = "none"++class RateLimitConfig(BaseModel):+ """Rate limit headers to respect."""+ remaining_header: str | None = None # e.g. "x-rate-limit-remaining"+ reset_header: str | None = None # e.g. "x-rate-limit-reset"+ reset_format: Literal["unix", "seconds", "iso8601"] = "unix"+ retry_after_header: str | None = "retry-after"++class PaginationConfig(BaseModel):+ """Uniform pagination descriptor — derived from Nango's providers.yaml patterns."""+ type: PaginationType = PaginationType.NONE+ cursor_path_in_response: str | None = None # JSONPath to next cursor+ cursor_name_in_request: str | None = None # query param name+ limit_name_in_request: str | None = "limit"+ response_path: str | None = None # JSONPath to data array+ link_path_in_response_body: str | None = None # for link-based pagination+ link_rel: str | None = None # for Link header pagination+ offset_calculation: Literal["per-page", "by-response-size"] = "by-response-size"++class EndpointSpec(BaseModel):+ """A single API endpoint, normalized."""+ method: Literal["GET", "POST", "PUT", "PATCH", "DELETE"]+ path: str # e.g. "/2/tweets"+ summary: str # one-line description+ description: str | None = None+ parameters: list["ParameterSpec"] = []+ request_body: "RequestBodySpec | None" = None+ response_schema: dict | None = None # JSON Schema of success response+ response_path: str | None = None # JSONPath to unwrap envelope+ scopes_required: list[str] = []+ rate_limit_group: str | None = None+ tags: list[str] = []++class ParameterSpec(BaseModel):+ name: str+ location: Literal["query", "path", "header", "cookie"]+ required: bool = False+ schema_type: str = "string"+ description: str | None = None+ enum_values: list[str] | None = None++class RequestBodySpec(BaseModel):+ content_type: str = "application/json"+ schema: dict # JSON Schema+ required: bool = True++class ConnectorCIR(BaseModel):+ """Canonical Internal Representation for one connector."""+ name: str # e.g. "twitter_x"+ display_name: str # e.g. "Twitter / X"+ categories: list[str] = [] # e.g. ["social", "marketing"]+ base_url: str # e.g. "https://api.x.com"+ auth: AuthMode+ auth_config: dict = {} # auth-mode-specific config+ default_headers: dict[str, str] = {}+ pagination: PaginationConfig = PaginationConfig()+ rate_limit: RateLimitConfig = RateLimitConfig()+ endpoints: list[EndpointSpec] = []+ docs_url: str | None = None+ version: str = "1.0.0"+```++### 4.3 Format-Specific Parsers++Each input format has a parser that emits `ConnectorCIR`:++```python+class OpenAPIParser:+ """Parse OpenAPI 3.x spec into ConnectorCIR."""++ def parse(self, spec: dict, overrides: dict | None = None) -> ConnectorCIR:+ """+ Walks the OpenAPI spec:+ 1. Extract info.title → display_name, servers[0].url → base_url+ 2. Extract securitySchemes → auth mode detection+ 3. Walk paths → EndpointSpec list+ 4. For each operation:+ - parameters (query, path, header)+ - requestBody → RequestBodySpec+ - responses.200.content.application/json.schema → response_schema+ 5. Apply overrides (pagination, rate_limit, response_path)+ because OpenAPI specs rarely encode these.+ """+ ...++class NangoProviderParser:+ """Parse a single entry from Nango's providers.yaml."""++ def parse(self, name: str, entry: dict) -> ConnectorCIR:+ """+ Direct mapping:+ - entry["auth_mode"] → AuthMode enum+ - entry["proxy"]["base_url"] → base_url+ - entry["proxy"]["paginate"] → PaginationConfig+ - entry["proxy"]["retry"] → RateLimitConfig+ - entry["proxy"]["headers"] → default_headers++ Note: Nango entries don't contain endpoint-level detail.+ Endpoints are discovered separately via:+ 1. Fetching the provider's OpenAPI spec (if available)+ 2. Scraping the provider's API docs+ 3. Manual endpoint registry+ """+ ...++class GraphQLParser:+ """Parse GraphQL SDL + introspection into ConnectorCIR."""++ def parse(self, sdl: str, introspection: dict,+ base_url: str, auth: AuthMode) -> ConnectorCIR:+ """+ Maps:+ - Query type fields → GET-equivalent EndpointSpecs+ - Mutation type fields → POST-equivalent EndpointSpecs+ - Input types → RequestBodySpec+ - Return types → response_schema+ """+ ...+```++### 4.4 Enrichment Pipeline++Raw specs are incomplete. The enrichment pipeline fills gaps:++```+Raw Spec → Parser → ConnectorCIR+ → Pagination Enricher (probe API or match known patterns)+ → Rate Limit Enricher (probe headers or match known patterns)+ → Response Envelope Enricher (detect common wrappers: { data, errors, meta })+ → Auth Scope Mapper (map endpoint tags to required scopes)+ → Example Generator (LLM-generate example request/response pairs)+ → Enriched ConnectorCIR+```++The Enrichment Pipeline can use an LLM to fill gaps:++```python+class SpecEnricher(dspy.Module):+ """Use an LLM to infer missing spec details from API docs."""++ def __init__(self):+ self.infer_pagination = dspy.ChainOfThought(+ "api_docs_snippet, known_endpoints -> pagination_config: PaginationConfig"+ )+ self.infer_envelope = dspy.ChainOfThought(+ "sample_response_json -> response_path: str, error_path: str"+ )+ self.generate_examples = dspy.ChainOfThought(+ "endpoint_spec -> example_request: dict, example_response: dict"+ )+```++### 4.5 Stub Generation++The final compilation step: `ConnectorCIR → Python stub string`. This is what the LLM sees in its context.++**Design principles for LLM-optimized stubs:**++1. **Typed, not schemaful** — Pydantic models for request/response, not raw JSON Schema. LLMs generate fewer errors against type hints than against schema objects.+2. **Docstrings over comments** — the docstring IS the prompt. Each method's docstring is a minimal, complete specification.+3. **Flat, not nested** — one class per connector with methods, not deep inheritance hierarchies.+4. **Example-bearing** — each method includes a `# Example:` block showing a minimal working call.+5. **Auth-invisible** — no auth parameters in method signatures. The broker handles it.+6. **Pagination-invisible** — all list endpoints return `AsyncIterator[T]`. The runtime paginates.+7. **Error-uniform** — all methods raise `ConnectorError(status, code, message, retry_after)`.++```python+# GENERATED STUB — twitter_x.pyi+# Do not edit. Regenerate with: uastl compile twitter_x++from uastl.types import ConnectorError, PageIterator+from pydantic import BaseModel+from datetime import datetime++class Tweet(BaseModel):+ id: str+ text: str+ author_id: str+ created_at: datetime+ public_metrics: "TweetMetrics | None" = None++class TweetMetrics(BaseModel):+ like_count: int+ retweet_count: int+ reply_count: int+ impression_count: int++class CreateTweetRequest(BaseModel):+ text: str+ reply_to: str | None = None+ media_ids: list[str] | None = None+ poll_options: list[str] | None = None+ poll_duration_minutes: int | None = None++class TwitterX:+ """Twitter/X API v2 connector.++ All methods are pre-authenticated. Pagination is automatic.+ Rate limits are handled with exponential backoff.+ """++ async def create_tweet(self, req: CreateTweetRequest) -> Tweet:+ """Post a new tweet.++ POST /2/tweets+ Scopes: tweet.write, users.read++ Example:+ tweet = await twitter.create_tweet(+ CreateTweetRequest(text="Hello from MachinaOS!")+ )+ print(tweet.id) # "1849573028375..."+ """+ ...++ async def get_tweet(self, tweet_id: str,+ fields: list[str] | None = None) -> Tweet:+ """Retrieve a single tweet by ID.++ GET /2/tweets/{id}+ Scopes: tweet.read++ Example:+ tweet = await twitter.get_tweet("1849573028375")+ print(tweet.text, tweet.public_metrics.like_count)+ """+ ...++ async def search_recent(self, query: str,+ max_results: int = 100) -> PageIterator[Tweet]:+ """Search tweets from the last 7 days.++ GET /2/tweets/search/recent+ Scopes: tweet.read+ Pagination: automatic cursor-based++ Example:+ async for tweet in twitter.search_recent("trending reels"):+ print(tweet.text)+ """+ ...++ async def get_user_timeline(self, user_id: str,+ max_results: int = 100) -> PageIterator[Tweet]:+ """Get tweets from a user's timeline.++ GET /2/users/{id}/tweets+ Scopes: tweet.read, users.read++ Example:+ async for tweet in twitter.get_user_timeline("12345"):+ print(tweet.created_at, tweet.text)+ """+ ...+```++```python+# GENERATED STUB — instagram.pyi++from uastl.types import ConnectorError, PageIterator+from pydantic import BaseModel++class IGMedia(BaseModel):+ id: str+ media_type: str # "IMAGE", "VIDEO", "CAROUSEL_ALBUM"+ media_url: str+ caption: str | None = None+ timestamp: str+ like_count: int | None = None+ comments_count: int | None = None+ permalink: str++class Instagram:+ """Instagram Graph API connector.++ All methods are pre-authenticated via Instagram Business account OAuth2.+ Rate limit: 200 calls/user/hour — handled automatically.+ """++ async def search_hashtag(self, hashtag: str) -> str:+ """Find the hashtag ID for a given hashtag name.++ GET /ig_hashtag_search?q={hashtag}++ Example:+ hashtag_id = await instagram.search_hashtag("trending")+ # Returns: "17843853986012965"+ """+ ...++ async def get_top_media(self, hashtag_id: str,+ fields: list[str] | None = None) -> PageIterator[IGMedia]:+ """Get top media for a hashtag.++ GET /{hashtag_id}/top_media++ Example:+ async for media in instagram.get_top_media("17843853986012965"):+ if media.media_type == "VIDEO": # reels+ print(media.caption, media.like_count)+ """+ ...+```++### 4.6 Stub Budget and Retrieval++Full stubs for 700 connectors would consume ~200k+ tokens. The system uses **retrieval** instead:++```python+class StubIndex:+ """Vector index over connector stubs for top-k retrieval."""++ def __init__(self, embedding_model: str = "text-embedding-3-small"):+ self.index: dict[str, StubEntry] = {}++ def add_connector(self, cir: ConnectorCIR, stub: str):+ """Index a connector with embedding of:+ - name + display_name + categories (weighted 2x)+ - all endpoint summaries+ - all model names+ """+ ...++ def retrieve(self, task: str, budget_tokens: int = 4000,+ max_connectors: int = 3) -> list[str]:+ """Retrieve top-k connector stubs that fit within token budget.++ Strategy:+ 1. Embed task description+ 2. Cosine similarity against connector embeddings+ 3. For top-k: include full stub if within budget, else truncate+ to class signature + relevant methods only+ 4. Return list of stub strings ready for prompt injection+ """+ ...+```++**Token budget allocation** (for a 200k context window):++| Component | Budget | Notes |+|---|---|---|+| System prompt + instructions | ~4k | Fixed |+| Retrieved connector stubs | ~4k | 2-3 connectors, methods relevant to task |+| Task description + examples | ~2k | From GEPA-optimized few-shot demos |+| REPL history (RLM mode) | ~8k | Truncated, rolling window |+| Code generation space | ~4k | LLM output budget |+| Safety margin | ~2k | Overhead |+| **Total active context** | **~24k** | Well within limits |++---++## 5. Code Generation Engine++### 5.1 DSPy Module Architecture++The code generation engine is a composed DSPy module:++```python+import dspy+from dspy.predict import CodeAct++class TaskDecomposer(dspy.Signature):+ """Decompose a digital task into ordered steps, each mapped to a connector."""+ task: str = dspy.InputField(desc="Natural language task description")+ available_connectors: str = dspy.InputField(desc="Comma-separated connector names")+ steps: list[str] = dspy.OutputField(desc="Ordered list of atomic steps")+ connectors_needed: list[str] = dspy.OutputField(desc="Connector name for each step")++class CodeGenerator(dspy.Signature):+ """Generate Python code using UniversalConnector stubs to accomplish a step."""+ step_description: str = dspy.InputField()+ connector_stubs: str = dspy.InputField(desc="Python stub code for available connectors")+ previous_results: str = dspy.InputField(desc="Variables from prior steps, as Python dict repr")+ code: str = dspy.OutputField(desc="Executable Python code using the connector API")++class VerificationGenerator(dspy.Signature):+ """Generate verification code: assertions, screenshots, console checks."""+ action_taken: str = dspy.InputField(desc="Description of what was just done")+ expected_outcome: str = dspy.InputField()+ verification_code: str = dspy.OutputField(desc="Python code for verification")++class DigitalTaskAgent(dspy.Module):+ """Top-level module: NL task → executable Python via connector stubs."""++ def __init__(self, stub_index: StubIndex, sandbox: CodeInterpreter):+ super().__init__()+ self.decompose = dspy.ChainOfThought(TaskDecomposer)+ self.generate = dspy.ChainOfThought(CodeGenerator)+ self.verify = dspy.ChainOfThought(VerificationGenerator)+ self.stub_index = stub_index+ self.sandbox = sandbox++ def forward(self, task: str) -> dspy.Prediction:+ # 1. Retrieve relevant connector stubs+ connector_names = self._identify_connectors(task)+ stubs = self.stub_index.retrieve(task, max_connectors=3)++ # 2. Decompose task into steps+ plan = self.decompose(+ task=task,+ available_connectors=", ".join(connector_names)+ )++ # 3. Execute each step+ results = {}+ traces = []+ for i, step in enumerate(plan.steps):+ # Generate code for this step+ code_pred = self.generate(+ step_description=step,+ connector_stubs="\n\n".join(stubs),+ previous_results=repr(results)+ )++ # Execute in sandbox+ exec_result = self.sandbox.execute(code_pred.code)+ traces.append({+ "step": step,+ "code": code_pred.code,+ "stdout": exec_result.stdout,+ "stderr": exec_result.stderr,+ "return_code": exec_result.return_code+ })++ # Store results for next step+ results[f"step_{i}"] = exec_result.stdout++ # Self-debug loop: if execution failed, retry with error context+ if exec_result.return_code != 0:+ for retry in range(3):+ debug_code = self._self_debug(+ code_pred.code, exec_result.stderr, stubs+ )+ exec_result = self.sandbox.execute(debug_code)+ if exec_result.return_code == 0:+ break++ # 4. Generate and run verification+ verify_pred = self.verify(+ action_taken=str(plan.steps),+ expected_outcome=f"Task '{task}' completed successfully"+ )+ verify_result = self.sandbox.execute(verify_pred.verification_code)++ return dspy.Prediction(+ plan=plan.steps,+ traces=traces,+ verification=verify_result,+ success=all(t["return_code"] == 0 for t in traces)+ )+```++### 5.2 RLM Mode for Long-Context Tasks++When the task involves large data (scraping many posts, processing message archives, analyzing trends across 1000+ items), the system switches to RLM mode:++```python+class LongContextTaskAgent(dspy.Module):+ """Uses RLM pattern: data stays in REPL variables, LLM processes via code."""++ def __init__(self):+ super().__init__()+ self.rlm = dspy.RLM(+ "task: str, connectors: str -> result: str",+ max_iterations=15,+ max_output_chars=5000+ )++ def forward(self, task: str, data_source: str) -> dspy.Prediction:+ return self.rlm(+ task=task,+ connectors="""+Available in REPL globals:+ - `twitter`: TwitterX connector instance (async methods, use await)+ - `instagram`: Instagram connector instance+ - `browser`: Playwright Browser instance+ - `llm_query(prompt: str) -> str`: Call sub-LLM for semantic tasks+ - `llm_query_batched(prompts: list[str]) -> list[str]`: Batch sub-LM calls++Write Python code to accomplish the task. Data stays in REPL variables.+Use llm_query() for semantic analysis. Use FINAL_VAR(name) when done.+"""+ )+```++### 5.3 Browser Automation Integration++For tasks requiring browser interaction (posting to Twitter, checking UI state):++```python+class BrowserTaskSignature(dspy.Signature):+ """Generate Playwright Python code for browser-based tasks."""+ task: str = dspy.InputField()+ page_observation: str = dspy.InputField(+ desc="Current page: AX-tree summary + interactive element indices"+ )+ screenshot_description: str = dspy.InputField(+ desc="LLM-generated description of current screenshot"+ )+ code: str = dspy.OutputField(+ desc="Playwright Python: use page.get_by_role(), page.locator(), expect()"+ )++class BrowserAgent(dspy.Module):+ """Agent that alternates between observing and acting on a browser page."""++ def __init__(self):+ super().__init__()+ self.act = dspy.ChainOfThought(BrowserTaskSignature)++ async def execute_browser_task(self, task: str, page):+ """Execute a browser task with observation-action loop."""+ for step in range(20): # max steps+ # Observe: get AX tree + screenshot+ ax_tree = await self._get_ax_tree(page)+ screenshot = await page.screenshot()+ description = await self._describe_screenshot(screenshot)++ # Generate action code+ pred = self.act(+ task=task,+ page_observation=ax_tree,+ screenshot_description=description+ )++ # Execute+ try:+ exec(pred.code, {"page": page, "expect": expect})+ except Exception as e:+ # Feed error back for self-correction+ continue++ # Check completion+ if await self._is_task_complete(page, task):+ # Final verification screenshot+ final_screenshot = await page.screenshot(+ path="verification.png"+ )+ return {"success": True, "screenshot": final_screenshot}++ return {"success": False, "reason": "max_steps_exceeded"}++ async def _get_ax_tree(self, page) -> str:+ """Extract simplified accessibility tree with interactive indices."""+ snapshot = await page.accessibility.snapshot()+ return self._simplify_ax_tree(snapshot, max_depth=4)+```++---++## 6. Sandboxed Execution Runtime++### 6.1 Runtime Architecture++```python+from abc import ABC, abstractmethod++class ExecutionResult(BaseModel):+ stdout: str+ stderr: str+ return_code: int+ duration_ms: float+ http_log: list[dict] = [] # captured request/response pairs+ screenshots: list[bytes] = [] # captured screenshots+ variables: dict[str, str] = {} # serialized REPL variable state++class SandboxRuntime(ABC):+ """Abstract sandbox interface. Implementations: E2B, Modal, Pyodide."""++ @abstractmethod+ async def execute(self, code: str) -> ExecutionResult: ...++ @abstractmethod+ async def install_packages(self, packages: list[str]) -> bool: ...++ @abstractmethod+ async def get_variable(self, name: str) -> str: ...++ @abstractmethod+ async def set_variable(self, name: str, value: str) -> None: ...++ @abstractmethod+ async def screenshot(self) -> bytes: ...++ @abstractmethod+ async def get_browser_page(self): ...+```++### 6.2 Sandbox Bootstrap++When a sandbox starts, it is pre-loaded with:++```python+SANDBOX_BOOTSTRAP = """+# === UASTL Runtime Bootstrap ===+import asyncio+import json+from uastl.runtime import UniversalConnectorProxy++# Credential broker proxy — talks to host via HTTP, never holds tokens+_broker = UniversalConnectorProxy(broker_url="http://host:9090/proxy")++# Pre-instantiated connectors (lazy-auth on first call)+twitter = _broker.get_connector("twitter_x")+instagram = _broker.get_connector("instagram")+slack = _broker.get_connector("slack")+notion = _broker.get_connector("notion")+# ... all connected connectors++# Browser (Playwright, pre-launched Chromium)+from playwright.async_api import async_playwright+_pw = await async_playwright().start()+browser = await _pw.chromium.launch(headless=True)+page = await browser.new_page()++# Sub-LLM for RLM pattern+def llm_query(prompt: str) -> str:+ \"\"\"Call sub-LM. Runs on host, not in sandbox.\"\"\"+ import requests+ resp = requests.post("http://host:9090/llm_query", json={"prompt": prompt})+ return resp.json()["result"]++def llm_query_batched(prompts: list[str]) -> list[str]:+ \"\"\"Batch sub-LM calls for efficiency.\"\"\"+ import requests+ resp = requests.post("http://host:9090/llm_query_batch", json={"prompts": prompts})+ return resp.json()["results"]++# Screenshot helper+async def take_screenshot(filename: str = "screen.png"):+ await page.screenshot(path=filename)+ return filename++# Console capture+_console_messages = []+page.on("console", lambda msg: _console_messages.append({+ "type": msg.type, "text": msg.text+}))+"""+```++### 6.3 Credential Broker (Host-Side)++The broker runs **outside** the sandbox and injects credentials at proxy time:++```python+class CredentialBroker:+ """Host-side credential proxy. The sandbox calls this via HTTP.+ Tokens never enter the sandbox or the LLM context."""++ def __init__(self, nango_secret_key: str):+ self.nango = NangoClient(secret_key=nango_secret_key)++ async def proxy_request(self, request: ProxyRequest) -> ProxyResponse:+ """+ 1. Look up connection credentials for (connector, user_id)+ 2. Inject auth header (Bearer, API-Key, Basic, etc.)+ 3. Apply rate-limit backoff if needed+ 4. Forward to upstream API+ 5. Capture response for trace logging+ 6. Return response to sandbox+ """+ # Get live credentials (auto-refreshed by Nango)+ connection = await self.nango.get_connection(+ provider_config_key=request.connector,+ connection_id=request.user_id+ )++ # Build upstream request+ headers = {**request.headers}+ if connection.credentials.type == "OAUTH2":+ headers["Authorization"] = f"Bearer {connection.credentials.access_token}"+ elif connection.credentials.type == "API_KEY":+ headers[connection.credentials.header_name] = connection.credentials.api_key++ # Forward with retry+ response = await self._forward_with_retry(+ method=request.method,+ url=f"{request.base_url}{request.path}",+ headers=headers,+ params=request.params,+ json=request.body+ )++ return ProxyResponse(+ status=response.status_code,+ headers=dict(response.headers),+ body=response.json()+ )+```++### 6.4 Egress Network Policy++The sandbox's network is restricted to:++```yaml+# Firecracker VM network policy+egress_allowlist:+ # Credential broker (host-side)+ - host:9090++ # Sub-LLM endpoint (host-side)+ - host:9091++ # Allowed upstream APIs (via broker only — direct blocked)+ # Direct API access is DENIED. All API calls go through the broker.++ # Package registries (for pip install)+ - pypi.org+ - files.pythonhosted.org++ # Browser targets (for Playwright)+ - "*.twitter.com"+ - "*.x.com"+ - "*.instagram.com"+ # ... per-task allowlist++# Everything else is DENIED by default+default_policy: DENY+```++---++## 7. Reflective Prompt Optimizer (GEPA Integration)++### 7.1 Metric Design++The metric is **decomposed** and returns both a score and a **textual critique**:++```python+class CodeExecutionMetric:+ """Decomposed metric for evaluating LLM-generated connector code.++ Returns (score: float, critique: str) where critique is the+ "Actionable Side Information" that GEPA needs for reflective mutation.+ """++ WEIGHTS = {+ "parse": 0.15, # Does the code parse as valid Python?+ "imports": 0.10, # Are required connector imports present?+ "calls": 0.15, # Are connector methods called correctly?+ "types": 0.10, # Do arguments match Pydantic model types?+ "execution": 0.30, # Does the code execute without errors?+ "output": 0.20, # Does the output match expected result?+ }++ def __call__(self, example, prediction, trace=None) -> tuple[float, str]:+ code = prediction.code+ critiques = []+ total_score = 0.0++ # 1. Parse check+ try:+ import ast+ ast.parse(code)+ total_score += self.WEIGHTS["parse"]+ except SyntaxError as e:+ critiques.append(f"PARSE FAIL at line {e.lineno}: {e.msg}")++ # 2. Import check+ required_imports = self._extract_required_imports(example.task)+ found_imports = self._extract_imports(code)+ missing = required_imports - found_imports+ if not missing:+ total_score += self.WEIGHTS["imports"]+ else:+ critiques.append(f"MISSING IMPORTS: {missing}")++ # 3. Call pattern check+ expected_calls = example.expected_connector_calls # e.g. ["twitter.create_tweet"]+ found_calls = self._extract_method_calls(code)+ call_match = len(set(expected_calls) & set(found_calls)) / max(len(expected_calls), 1)+ total_score += self.WEIGHTS["calls"] * call_match+ if call_match < 1.0:+ critiques.append(+ f"CALL MISMATCH: expected {expected_calls}, found {found_calls}"+ )++ # 4. Type check (static analysis against stubs)+ type_errors = self._check_types_against_stubs(code, example.stubs)+ if not type_errors:+ total_score += self.WEIGHTS["types"]+ else:+ critiques.append(f"TYPE ERRORS: {type_errors[:3]}") # top 3++ # 5. Execution check (sandbox dry-run with mocked APIs)+ exec_result = self._sandbox_execute(code, mock=True)+ if exec_result.return_code == 0:+ total_score += self.WEIGHTS["execution"]+ else:+ critiques.append(+ f"EXECUTION FAIL (rc={exec_result.return_code}): "+ f"{exec_result.stderr[:500]}"+ )++ # 6. Output quality (LLM judge or string match)+ if exec_result.return_code == 0 and example.expected_output:+ output_score = self._score_output(+ exec_result.stdout, example.expected_output+ )+ total_score += self.WEIGHTS["output"] * output_score+ if output_score < 0.8:+ critiques.append(+ f"OUTPUT MISMATCH: got '{exec_result.stdout[:200]}', "+ f"expected pattern '{example.expected_output[:200]}'"+ )++ critique = " | ".join(critiques) if critiques else "All checks passed."+ return total_score, critique+```++### 7.2 GEPA Compilation++```python+import dspy+from dspy.teleprompt import GEPA++# Configure+dspy.configure(lm=dspy.LM("anthropic/claude-sonnet-4-6")) # task LM+reflection_lm = dspy.LM("anthropic/claude-opus-4-6") # reflection LM (can be stronger)++# Define the agent module+agent = DigitalTaskAgent(+ stub_index=stub_index,+ sandbox=E2BSandbox()+)++# Build training set (20-60 examples)+trainset = [+ dspy.Example(+ task="Search for tweets about #AI and print the top 5 by likes",+ stubs=stub_index.retrieve("search tweets AI"),+ expected_connector_calls=["twitter.search_recent"],+ expected_output="Tweet text with like counts"+ ).with_inputs("task"),+ dspy.Example(+ task="Find top trending reels on Instagram for #travel and post a summary tweet",+ stubs=stub_index.retrieve("instagram trending reels twitter post"),+ expected_connector_calls=["instagram.search_hashtag", "instagram.get_top_media", "twitter.create_tweet"],+ expected_output="Tweet posted successfully"+ ).with_inputs("task"),+ # ... 18-58 more examples spanning task categories+]++valset = trainset[::4] # hold out every 4th for validation++# Compile with GEPA+optimizer = GEPA(+ metric=CodeExecutionMetric(),+ num_generations=40, # evolutionary generations+ population_size=10, # candidates per generation+ reflection_lm=reflection_lm,+ # GEPA-specific: Pareto selection, reflective mutation, rich textual feedback+)++optimized_agent = optimizer.compile(+ agent,+ trainset=trainset,+ valset=valset,+)++# Save compiled prompts (portable across LMs)+optimized_agent.save("compiled_digital_task_agent.json")+```++### 7.3 Continuous Improvement Loop++```+Production execution+ → Trace captured (code, stdout, stderr, screenshots, HTTP log)+ → Metric evaluated (decomposed score + textual critique)+ → If score < threshold:+ → Trace added to training set+ → GEPA re-compiled periodically (nightly or on N new traces)+ → New prompts deployed+ → If score >= threshold:+ → Trace added as positive example (few-shot demo candidate)+```++---++## 8. End-to-End Example++**Task:** "Check top trending reels on Instagram for #fitness and generate a Twitter post summarizing them."++### Step 1: Stub Retrieval++The StubIndex retrieves `instagram.pyi` and `twitter_x.pyi` stubs (§4.5).++### Step 2: Task Decomposition++```python+plan = decompose(+ task="Check top trending reels on Instagram for #fitness and generate a Twitter post summarizing them",+ available_connectors="instagram, twitter_x"+)+# plan.steps = [+# "Search Instagram for hashtag ID of 'fitness'",+# "Fetch top media for that hashtag, filter to VIDEO (reels)",+# "Extract captions and engagement metrics from top 5 reels",+# "Generate a summary tweet text",+# "Post the tweet via Twitter/X API",+# "Verify the tweet was posted"+# ]+```++### Step 3: Code Generation (single unified block)++The LLM emits:++```python+# Step 1-2: Get trending reels+hashtag_id = await instagram.search_hashtag("fitness")++top_reels = []+async for media in instagram.get_top_media(hashtag_id):+ if media.media_type == "VIDEO":+ top_reels.append(media)+ if len(top_reels) >= 5:+ break++# Step 3: Extract data+summaries = []+for reel in top_reels:+ summaries.append(+ f"- {reel.caption[:80]}... ({reel.like_count} likes)"+ )++# Step 4: Generate tweet text+summary_text = "\n".join(summaries)+tweet_text = llm_query(+ f"Write a concise, engaging tweet (under 280 chars) summarizing "+ f"these trending #fitness reels:\n{summary_text}"+)++# Step 5: Post tweet+from uastl.stubs.twitter_x import CreateTweetRequest+tweet = await twitter.create_tweet(+ CreateTweetRequest(text=tweet_text)+)+print(f"Tweet posted: {tweet.id}")++# Step 6: Verify+assert tweet.id is not None+print(f"SUCCESS: Posted tweet {tweet.id}")+```++### Step 4: Sandbox Execution++The code runs in E2B. The broker intercepts `instagram.*` and `twitter.*` calls, injects OAuth tokens, handles pagination, and returns responses. `llm_query()` calls the host-side sub-LM.++### Step 5: Trace Capture++```json+{+ "task": "Check top trending reels on Instagram for #fitness...",+ "steps": [+ {"code": "hashtag_id = await instagram.search_hashtag('fitness')",+ "stdout": "17843853986012965", "stderr": "", "rc": 0},+ {"code": "async for media in instagram.get_top_media(...)...",+ "stdout": "5 reels found", "stderr": "", "rc": 0},+ {"code": "tweet = await twitter.create_tweet(...)",+ "stdout": "Tweet posted: 1849573028375", "stderr": "", "rc": 0}+ ],+ "http_log": [+ {"method": "GET", "url": "https://graph.instagram.com/ig_hashtag_search?q=fitness",+ "status": 200, "latency_ms": 234},+ {"method": "GET", "url": "https://graph.instagram.com/17843.../top_media",+ "status": 200, "latency_ms": 456},+ {"method": "POST", "url": "https://api.x.com/2/tweets",+ "status": 201, "latency_ms": 312}+ ],+ "metric_score": 0.95,+ "metric_critique": "All checks passed."+}+```++---++## 9. Security Model++### 9.1 Threat Model++| Threat | Mitigation |+|---|---|+| LLM exfiltrates credentials | Credentials never enter LLM context or sandbox. Broker-only access. |+| Generated code accesses unauthorized APIs | Default-deny egress allowlist at VM network layer. Only broker HTTP allowed. |+| Prompt injection via tool outputs | Tool outputs are treated as untrusted data. Plan-then-execute: outputs cannot rewrite plan. |+| Runaway cost (infinite loops, API abuse) | Per-task step budget (30), per-session token budget, per-API call budget, hard kill at 2× expected cost. |+| Sandbox escape | Firecracker microVM: separate kernel per sandbox. Hardware-level isolation. |+| Data leakage between users | Per-user sandbox instances. No shared state. Sandbox destroyed after task completion. |++### 9.2 Policy-as-Code++```python+class ActionPolicy:+ """OPA/Cedar-style policy checked before every mutating action."""++ REQUIRES_APPROVAL = {+ "twitter.create_tweet",+ "twitter.delete_tweet",+ "slack.send_message",+ "notion.create_page",+ # ... any write operation+ }++ ALWAYS_ALLOWED = {+ "twitter.search_recent",+ "instagram.get_top_media",+ "instagram.search_hashtag",+ # ... all read operations+ }++ async def check(self, action: str, args: dict, user_id: str) -> PolicyDecision:+ if action in self.ALWAYS_ALLOWED:+ return PolicyDecision.ALLOW+ if action in self.REQUIRES_APPROVAL:+ # Check if user has pre-approved this action type+ if await self._user_has_standing_approval(user_id, action):+ return PolicyDecision.ALLOW+ return PolicyDecision.REQUIRE_HUMAN_APPROVAL+ return PolicyDecision.DENY+```++---++## 10. Schema Registry Operations++### 10.1 Adding a New Connector++```bash+# From OpenAPI spec+uastl add-connector \+ --name "notion" \+ --source openapi \+ --spec-url "https://raw.githubusercontent.com/.../notion-openapi.json" \+ --auth-mode oauth2 \+ --base-url "https://api.notion.com" \+ --pagination-type cursor \+ --pagination-cursor-path "next_cursor" \+ --pagination-cursor-param "start_cursor" \+ --response-path "results"++# From Nango providers.yaml entry+uastl add-connector \+ --name "hubspot" \+ --source nango \+ --nango-provider-key "hubspot"++# Auto-discovery: scrape docs + LLM enrichment+uastl add-connector \+ --name "linear" \+ --source auto \+ --docs-url "https://developers.linear.app/docs"+```++### 10.2 Connector Versioning++```python+class ConnectorVersion(BaseModel):+ connector: str+ version: str # semver+ cir_hash: str # SHA256 of serialized CIR+ stub_hash: str # SHA256 of generated stub+ compiled_at: datetime+ breaking_changes: list[str] # e.g. ["removed endpoint GET /v1/old"]+ migration_notes: str | None+```++When a connector's upstream API changes:+1. Re-parse spec → new CIR+2. Diff against previous CIR → detect breaking changes+3. Re-generate stub+4. Re-index in StubIndex+5. Flag affected GEPA training examples for re-evaluation++---++## 11. Connector Categories and Task Templates++### 11.1 Category-Specific Patterns++```python+CONNECTOR_CATEGORIES = {+ "social": {+ "common_operations": ["post", "search", "get_timeline", "get_trending"],+ "browser_fallback": True, # some operations need browser (e.g., reels)+ "rate_limit_sensitivity": "high",+ },+ "crm": {+ "common_operations": ["create_contact", "update_deal", "search", "list"],+ "browser_fallback": False,+ "rate_limit_sensitivity": "medium",+ },+ "productivity": {+ "common_operations": ["create_task", "update_status", "list_items", "search"],+ "browser_fallback": False,+ "rate_limit_sensitivity": "low",+ },+ "communication": {+ "common_operations": ["send_message", "list_channels", "search_messages"],+ "browser_fallback": False,+ "rate_limit_sensitivity": "medium",+ },+}+```++### 11.2 Task Templates++Pre-compiled task patterns that the GEPA optimizer can specialize:++```python+TASK_TEMPLATES = {+ "cross_post": {+ "description": "Read from source platform, transform, post to target",+ "pattern": "read(source) → transform(llm) → write(target) → verify",+ "connectors_needed": 2,+ "requires_browser": False,+ },+ "trend_analysis": {+ "description": "Aggregate trending data, analyze, report",+ "pattern": "search(source) → collect(paginate) → analyze(llm) → format",+ "connectors_needed": 1,+ "requires_browser": False,+ "prefers_rlm": True, # potentially large data+ },+ "browser_action": {+ "description": "Navigate, interact, verify via browser",+ "pattern": "navigate(url) → observe(ax_tree+screenshot) → act(click/type) → verify(screenshot)",+ "connectors_needed": 0,+ "requires_browser": True,+ },+ "multi_step_workflow": {+ "description": "Chain multiple API operations with data dependencies",+ "pattern": "step1(api_a) → transform → step2(api_b) → step3(api_c) → verify",+ "connectors_needed": "2+",+ "requires_browser": False,+ },+}+```++---++## 12. Implementation Roadmap++### Phase 1: Foundation (Weeks 1-4)++- [ ] Implement `ConnectorCIR` Pydantic models+- [ ] Build `OpenAPIParser` and `NangoProviderParser`+- [ ] Stub generator: CIR → Python `.pyi` with typed models and docstrings+- [ ] Manual stubs for 5 connectors: Twitter/X, Instagram, Slack, Notion, GitHub+- [ ] StubIndex with simple embedding-based retrieval+- [ ] Basic E2B sandbox integration with bootstrap script++### Phase 2: Code Generation (Weeks 5-8)++- [ ] DSPy module: `DigitalTaskAgent` with decompose → generate → execute loop+- [ ] Credential Broker: host-side proxy with Nango integration+- [ ] Self-debug loop (3 retries with error feedback)+- [ ] Playwright browser integration in sandbox+- [ ] Screenshot capture and AX-tree extraction+- [ ] 20 training examples across task templates++### Phase 3: Optimization (Weeks 9-12)++- [ ] `CodeExecutionMetric` with decomposed scoring and textual critique+- [ ] GEPA compilation pipeline: train → optimize → evaluate → deploy+- [ ] RLM integration for long-context tasks+- [ ] Continuous improvement loop (trace → retrain)+- [ ] A/B testing framework for prompt versions++### Phase 4: Scale (Weeks 13-16)++- [ ] Auto-discovery pipeline: docs URL → OpenAPI spec → CIR → stub+- [ ] Scale to 50+ connectors+- [ ] Connector versioning and breaking-change detection+- [ ] Policy-as-code enforcement (OPA integration)+- [ ] Production monitoring: trace SIEM, cost tracking, success rate dashboards++---++## 13. Open Questions++1. **Stub granularity:** Should stubs include ALL endpoints or only the top-20 most-used per connector? Full stubs improve coverage but cost tokens. Current design favors retrieval-based selection of relevant methods only.++2. **Mock vs. live execution during GEPA training:** Mock APIs are faster and cheaper but don't catch real-world edge cases (rate limits, auth failures, schema drift). Recommendation: mock for initial compilation, live for periodic re-evaluation.++3. **Browser vs. API for social media:** Instagram's official API is limited (no reels trending endpoint for most apps). Should the system prefer browser automation for discovery + API for posting? Current design: hybrid, with `browser_fallback: True` per category.++4. **Connector stub language:** Python stubs are chosen because the LLM generates Python. But Nango's integration code is TypeScript. Should UASTL compile to both? Current design: Python-only, with TypeScript as a future extension.++5. **Multi-user credential isolation:** When multiple users connect the same connector, the broker must correctly route `user_id → connection`. This is handled by Nango's `connectionId` but needs careful integration with the sandbox's per-user isolation.++---++## 14. References++- **CodeAct:** Wang et al., "Executable Code Actions Elicit Better LLM Agents," ICML 2024. arXiv:2402.01030+- **RLM:** Zhang, Kraska, Khattab, "Recursive Language Models," MIT CSAIL, 2025. alexzhang13.github.io/blog/2025/rlm/+- **GEPA:** Agrawal et al., "Reflective Prompt Evolution Can Outperform Reinforcement Learning," ICLR 2026 Oral. arXiv:2507.19457+- **DSPy:** Khattab et al., Stanford NLP. github.com/stanfordnlp/dspy+- **Nango:** NangoHQ. github.com/NangoHQ/nango — `providers.yaml` schema, proxy architecture, unified auth+- **SWE-Agent:** Yang et al., "Agent-Computer Interfaces Enable Automated Software Engineering," NeurIPS 2024. arXiv:2405.15793+- **OpenHands:** Wang et al., "OpenHands: An Open Platform for AI Software Developers as Generalist Agents," ICLR 2025.+- **browser-use:** github.com/browser-use/browser-use — DOM service, AX-tree indexing, screenshot observation+- **E2B:** e2b.dev — Firecracker microVM sandbox for AI agents+- **Gorilla:** Patil et al., "Gorilla: Large Language Model Connected with Massive APIs." arXiv:2305.15334++---++*End of RFC-0001.*diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex a30a225a..99c4cb38 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -11,18 +11,12 @@ importers:agent-browser:specifier: latestversion: 0.26.0- concurrently:- specifier: ^9.2.1- version: 9.2.1cross-env:specifier: ^7.0.3version: 7.0.3edgymeow:specifier: 0.0.20version: 0.0.20- rimraf:- specifier: ^6.0.1- version: 6.1.2temporal-server:specifier: ^0.0.10version: 0.0.10@@ -143,9 +137,6 @@ importers:react-hook-form:specifier: ^7.72.1version: 7.72.1([email protected])- react-js-cron:- specifier: ^5.2.0- version: 5.2.0([email protected]([email protected]([email protected]))([email protected]))([email protected]([email protected]))([email protected])react-markdown:specifier: ^10.1.0version: 10.1.0(@types/[email protected])([email protected])@@ -3164,11 +3155,6 @@ packages:resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}- resolution: {integrity: sha512-fsfrO0MxV64Znoy8/l1vVIjjHa29SZyyqPgQBwhiDcaW8wJc2W3XWVOGx4M3oJBnv/zdUZIIp1gDeS98GzP8Ng==}- engines: {node: '>=18'}- hasBin: true-resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==}@@ -4003,10 +3989,6 @@ packages:deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting [email protected]hasBin: true- resolution: {integrity: sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==}- engines: {node: 20 || >=22}-resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}engines: {node: '>=18'}@@ -4588,10 +4570,6 @@ packages:resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}- resolution: {integrity: sha512-vFrFJkWtJvJnD5hg+hJvVE8Lh/TcMzKnTgCWmtBipwI5yLX/iX+5UB2tfuyODF5E7k9xEzMdYgGqaSb1c0c5Yw==}- engines: {node: 20 || >=22}-resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}@@ -5112,10 +5090,6 @@ packages:resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}engines: {node: '>=16 || 14 >=14.18'}- resolution: {integrity: sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==}- engines: {node: 20 || >=22}-resolution: {integrity: sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==}@@ -5584,13 +5558,6 @@ packages:resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}- resolution: {integrity: sha512-+Mxm3cS7qmIoAIz7NVY27jvsJKNZ4tx+H/nNtMUJW4DcKR7jUIL1GP0jOD79K5j86Dq8jvShKJMh30+c8bmVtA==}- peerDependencies:- antd: '>=5.8.0'- react: '>=17.0.0'- react-dom: '>=17.0.0'-resolution: {integrity: sha512-fzmrwMBNGIAiDIrdFMV3NvJhUNl01QC9EMcI8SP7osg51N4j+z6w4tx9i2yWxEEXZ2armLV6EtkFd3KST8PYiA==}peerDependencies:@@ -5798,11 +5765,6 @@ packages:resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}engines: {iojs: '>=1.0.0', node: '>=0.10.0'}- resolution: {integrity: sha512-cFCkPslJv7BAXJsYlK1dZsbP8/ZNLkCAQ0bi1hf5EKX2QHegmDFEFA6QhuYJlk7UDdc+02JjO80YSOrWPpw06g==}- engines: {node: 20 || >=22}- hasBin: true-resolution: {integrity: sha512-IXgzBWvWQwE6PrDI05OvmXUIruQTcoMDzRsOd5CDvHCVLcLHMTSYvOK5Cm46kWqlV3yAbuSpBZdJ5oP5OUoStg==}@@ -5847,9 +5809,6 @@ packages:resolution: {integrity: sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==}- resolution: {integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==}-resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}@@ -5926,10 +5885,6 @@ packages:resolution: {integrity: sha512-jyVd+kU2X+mWKMmGhx4fpWbPsjvD53k9ivqetutVW/BQ+WIZoDoP4d8vUMGezV6saZsiNoW2f9GIhg9Dondohg==}- resolution: {integrity: sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==}- engines: {node: '>= 0.4'}-resolution: {integrity: sha512-pDIqmaP/zJWHNV8bJKp0tD0CZ6OkF+lWTIvmNRLktlTjBjN3+durr19JarS657U1oSEf/WrSYmdzwr9CeD6m2Q==}peerDependencies:@@ -6099,10 +6054,6 @@ packages:resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}engines: {node: '>=8'}- resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==}- engines: {node: '>=10'}-resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}engines: {node: '>= 0.4'}@@ -6228,10 +6179,6 @@ packages:resolution: {integrity: sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==}engines: {node: '>=18'}- resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}- hasBin: true-resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}@@ -9948,15 +9895,6 @@ snapshots:- dependencies:- chalk: 4.1.2- rxjs: 7.8.2- shell-quote: 1.8.3- supports-color: 8.1.1- tree-kill: 1.2.2- yargs: 17.7.2-@@ -10933,12 +10871,6 @@ snapshots:package-json-from-dist: 1.0.1path-scurry: 1.11.1- dependencies:- minimatch: 10.1.1- minipass: 7.1.2- path-scurry: 2.0.1-@@ -11543,8 +11475,6 @@ snapshots:- [email protected]: {}-dependencies:yallist: 3.1.1@@ -12370,11 +12300,6 @@ snapshots:lru-cache: 10.4.3minipass: 7.1.2- dependencies:- lru-cache: 11.2.5- minipass: 7.1.2-@@ -12967,12 +12892,6 @@ snapshots:- [email protected]([email protected]([email protected]([email protected]))([email protected]))([email protected]([email protected]))([email protected]):- dependencies:- react: 19.2.1- react-dom: 19.2.1([email protected])-dependencies:'@babel/runtime': 7.28.4@@ -13273,11 +13192,6 @@ snapshots:- dependencies:- glob: 13.0.0- package-json-from-dist: 1.0.1-@@ -13346,10 +13260,6 @@ snapshots:- dependencies:- tslib: 2.8.1-@@ -13476,8 +13386,6 @@ snapshots:- [email protected]: {}-dependencies:'@shikijs/core': 3.19.0@@ -13639,10 +13547,6 @@ snapshots:dependencies:has-flag: 4.0.0- dependencies:- has-flag: 4.0.0-@@ -13757,8 +13661,6 @@ snapshots:dependencies:punycode: 2.3.1- [email protected]: {}-diff --git a/server/config/model_registry.json b/server/config/model_registry.jsonindex a48ff6eb..9772d524 100644--- a/server/config/model_registry.json+++ b/server/config/model_registry.json@@ -1,8 +1,467 @@{- "_generated": "2026-04-25T10:54:49.138467+00:00",+ "_generated": "2026-04-30T05:49:05.631262+00:00","_source": "openrouter",- "_model_count": 355,+ "_model_count": 368,"models": {+ "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free": {+ "id": "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",+ "name": "NVIDIA: Nemotron 3 Nano Omni (free)",+ "provider": "nvidia",+ "local_id": "nemotron-3-nano-omni-30b-a3b-reasoning:free",+ "context_length": 256000,+ "max_output_tokens": 65536,+ "input_price_per_mtok": 0.0,+ "output_price_per_mtok": 0.0,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_tokens",+ "reasoning",+ "seed",+ "temperature",+ "tool_choice",+ "tools",+ "top_p"+ ]+ },+ "poolside/laguna-xs.2:free": {+ "id": "poolside/laguna-xs.2:free",+ "name": "Poolside: Laguna XS.2 (free)",+ "provider": "poolside",+ "local_id": "laguna-xs.2:free",+ "context_length": 131072,+ "max_output_tokens": 8192,+ "input_price_per_mtok": 0.0,+ "output_price_per_mtok": 0.0,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_tokens",+ "reasoning",+ "temperature",+ "tool_choice",+ "tools"+ ]+ },+ "poolside/laguna-m.1:free": {+ "id": "poolside/laguna-m.1:free",+ "name": "Poolside: Laguna M.1 (free)",+ "provider": "poolside",+ "local_id": "laguna-m.1:free",+ "context_length": 131072,+ "max_output_tokens": 8192,+ "input_price_per_mtok": 0.0,+ "output_price_per_mtok": 0.0,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_tokens",+ "reasoning",+ "temperature",+ "tool_choice",+ "tools"+ ]+ },+ "~anthropic/claude-haiku-latest": {+ "id": "~anthropic/claude-haiku-latest",+ "name": "Anthropic Claude Haiku Latest",+ "provider": "~anthropic",+ "local_id": "claude-haiku-latest",+ "context_length": 200000,+ "max_output_tokens": 64000,+ "input_price_per_mtok": 1.0,+ "output_price_per_mtok": 5.0,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_tokens",+ "reasoning",+ "response_format",+ "stop",+ "structured_outputs",+ "temperature",+ "tool_choice",+ "tools",+ "top_k",+ "top_p"+ ]+ },+ "~openai/gpt-mini-latest": {+ "id": "~openai/gpt-mini-latest",+ "name": "OpenAI GPT Mini Latest",+ "provider": "~openai",+ "local_id": "gpt-mini-latest",+ "context_length": 400000,+ "max_output_tokens": 128000,+ "input_price_per_mtok": 0.75,+ "output_price_per_mtok": 4.5,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_completion_tokens",+ "max_tokens",+ "reasoning",+ "response_format",+ "seed",+ "structured_outputs",+ "tool_choice",+ "tools"+ ]+ },+ "~google/gemini-pro-latest": {+ "id": "~google/gemini-pro-latest",+ "name": "Google Gemini Pro Latest",+ "provider": "~google",+ "local_id": "gemini-pro-latest",+ "context_length": 1048576,+ "max_output_tokens": 65536,+ "input_price_per_mtok": 2.0,+ "output_price_per_mtok": 12.0,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_tokens",+ "reasoning",+ "response_format",+ "seed",+ "stop",+ "structured_outputs",+ "temperature",+ "tool_choice",+ "tools",+ "top_p"+ ]+ },+ "~moonshotai/kimi-latest": {+ "id": "~moonshotai/kimi-latest",+ "name": "MoonshotAI Kimi Latest",+ "provider": "~moonshotai",+ "local_id": "kimi-latest",+ "context_length": 262144,+ "max_output_tokens": 16384,+ "input_price_per_mtok": 0.75,+ "output_price_per_mtok": 3.5,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "frequency_penalty",+ "include_reasoning",+ "logit_bias",+ "logprobs",+ "max_tokens",+ "min_p",+ "parallel_tool_calls",+ "presence_penalty",+ "reasoning",+ "reasoning_effort",+ "repetition_penalty",+ "response_format",+ "seed",+ "stop",+ "structured_outputs",+ "temperature",+ "tool_choice",+ "tools",+ "top_k",+ "top_logprobs",+ "top_p"+ ]+ },+ "~google/gemini-flash-latest": {+ "id": "~google/gemini-flash-latest",+ "name": "Google Gemini Flash Latest",+ "provider": "~google",+ "local_id": "gemini-flash-latest",+ "context_length": 1048576,+ "max_output_tokens": 65536,+ "input_price_per_mtok": 0.5,+ "output_price_per_mtok": 3.0,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_tokens",+ "reasoning",+ "response_format",+ "seed",+ "stop",+ "structured_outputs",+ "temperature",+ "tool_choice",+ "tools",+ "top_p"+ ]+ },+ "~anthropic/claude-sonnet-latest": {+ "id": "~anthropic/claude-sonnet-latest",+ "name": "Anthropic Claude Sonnet Latest",+ "provider": "~anthropic",+ "local_id": "claude-sonnet-latest",+ "context_length": 1000000,+ "max_output_tokens": 128000,+ "input_price_per_mtok": 3.0,+ "output_price_per_mtok": 15.0,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_completion_tokens",+ "max_tokens",+ "reasoning",+ "response_format",+ "stop",+ "structured_outputs",+ "temperature",+ "tool_choice",+ "tools",+ "top_k",+ "top_p",+ "verbosity"+ ]+ },+ "~openai/gpt-latest": {+ "id": "~openai/gpt-latest",+ "name": "OpenAI GPT Latest",+ "provider": "~openai",+ "local_id": "gpt-latest",+ "context_length": 1050000,+ "max_output_tokens": 128000,+ "input_price_per_mtok": 5.0,+ "output_price_per_mtok": 30.0,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_completion_tokens",+ "max_tokens",+ "reasoning",+ "response_format",+ "seed",+ "structured_outputs",+ "tool_choice",+ "tools"+ ]+ },+ "qwen/qwen3.5-plus-20260420": {+ "id": "qwen/qwen3.5-plus-20260420",+ "name": "Qwen: Qwen3.5 Plus 2026-04-20",+ "provider": "qwen",+ "local_id": "qwen3.5-plus-20260420",+ "context_length": 1000000,+ "max_output_tokens": 65536,+ "input_price_per_mtok": 0.4,+ "output_price_per_mtok": 2.4,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_tokens",+ "presence_penalty",+ "reasoning",+ "response_format",+ "seed",+ "structured_outputs",+ "temperature",+ "tool_choice",+ "tools",+ "top_p"+ ]+ },+ "qwen/qwen3.6-flash": {+ "id": "qwen/qwen3.6-flash",+ "name": "Qwen: Qwen3.6 Flash",+ "provider": "qwen",+ "local_id": "qwen3.6-flash",+ "context_length": 1000000,+ "max_output_tokens": 65536,+ "input_price_per_mtok": 0.25,+ "output_price_per_mtok": 1.5,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "max_tokens",+ "presence_penalty",+ "reasoning",+ "response_format",+ "seed",+ "structured_outputs",+ "temperature",+ "tool_choice",+ "tools",+ "top_p"+ ]+ },+ "qwen/qwen3.6-35b-a3b": {+ "id": "qwen/qwen3.6-35b-a3b",+ "name": "Qwen: Qwen3.6 35B A3B",+ "provider": "qwen",+ "local_id": "qwen3.6-35b-a3b",+ "context_length": 262144,+ "max_output_tokens": 65536,+ "input_price_per_mtok": 0.1612,+ "output_price_per_mtok": 0.9652,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "frequency_penalty",+ "include_reasoning",+ "logit_bias",+ "max_tokens",+ "min_p",+ "presence_penalty",+ "reasoning",+ "repetition_penalty",+ "response_format",+ "seed",+ "stop",+ "structured_outputs",+ "temperature",+ "top_k",+ "top_p"+ ]+ },+ "qwen/qwen3.6-max-preview": {+ "id": "qwen/qwen3.6-max-preview",+ "name": "Qwen: Qwen3.6 Max Preview",+ "provider": "qwen",+ "local_id": "qwen3.6-max-preview",+ "context_length": 262144,+ "max_output_tokens": 65536,+ "input_price_per_mtok": 1.04,+ "output_price_per_mtok": 6.24,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "include_reasoning",+ "logprobs",+ "max_tokens",+ "presence_penalty",+ "reasoning",+ "response_format",+ "seed",+ "structured_outputs",+ "temperature",+ "tool_choice",+ "tools",+ "top_logprobs",+ "top_p"+ ]+ },+ "qwen/qwen3.6-27b": {+ "id": "qwen/qwen3.6-27b",+ "name": "Qwen: Qwen3.6 27B",+ "provider": "qwen",+ "local_id": "qwen3.6-27b",+ "context_length": 256000,+ "max_output_tokens": 65536,+ "input_price_per_mtok": 0.325,+ "output_price_per_mtok": 3.25,+ "supports_thinking": false,+ "thinking_type": "none",+ "temperature_range": [+ 0.0,+ 2.0+ ],+ "is_reasoning_model": false,+ "supported_parameters": [+ "frequency_penalty",+ "include_reasoning",+ "logit_bias",+ "logprobs",+ "max_tokens",+ "min_p",+ "presence_penalty",+ "reasoning",+ "repetition_penalty",+ "response_format",+ "seed",+ "stop",+ "structured_outputs",+ "temperature",+ "tool_choice",+ "tools",+ "top_k",+ "top_logprobs",+ "top_p"+ ]+ },"openai/gpt-5.5-pro": {"id": "openai/gpt-5.5-pro","name": "OpenAI: GPT-5.5 Pro",@@ -48,6 +507,7 @@"is_reasoning_model": false,"supported_parameters": ["include_reasoning",+ "max_completion_tokens","max_tokens","reasoning","response_format",@@ -64,8 +524,8 @@"local_id": "deepseek-v4-pro","context_length": 1048576,"max_output_tokens": 384000,- "input_price_per_mtok": 1.74,- "output_price_per_mtok": 3.48,+ "input_price_per_mtok": 0.435,+ "output_price_per_mtok": 0.87,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -84,6 +544,7 @@"reasoning","repetition_penalty","response_format",+ "seed","stop","structured_outputs","temperature",@@ -285,15 +746,15 @@"top_logprobs"]},- "inclusionai/ling-2.6-flash:free": {- "id": "inclusionai/ling-2.6-flash:free",- "name": "inclusionAI: Ling-2.6-flash (free)",+ "inclusionai/ling-2.6-flash": {+ "id": "inclusionai/ling-2.6-flash",+ "name": "inclusionAI: Ling-2.6-flash","provider": "inclusionai",- "local_id": "ling-2.6-flash:free",+ "local_id": "ling-2.6-flash","context_length": 262144,"max_output_tokens": 32768,- "input_price_per_mtok": 0.0,- "output_price_per_mtok": 0.0,+ "input_price_per_mtok": 0.08,+ "output_price_per_mtok": 0.24,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -397,10 +858,10 @@"name": "MoonshotAI: Kimi K2.6","provider": "moonshotai","local_id": "kimi-k2.6",- "context_length": 256000,- "max_output_tokens": 65536,- "input_price_per_mtok": 0.7448,- "output_price_per_mtok": 4.655,+ "context_length": 262144,+ "max_output_tokens": 16384,+ "input_price_per_mtok": 0.75,+ "output_price_per_mtok": 3.5,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -2658,27 +3119,6 @@"top_p"]},- "mistralai/mistral-small-creative": {- "id": "mistralai/mistral-small-creative",- "name": "Mistral: Mistral Small Creative",- "provider": "mistralai",- "local_id": "mistral-small-creative",- "context_length": 32768,- "max_output_tokens": 0,- "input_price_per_mtok": 0.1,- "output_price_per_mtok": 0.3,- "supports_thinking": false,- "thinking_type": "none",- "temperature_range": [- 0.0,- 2.0- ],- "is_reasoning_model": false,- "supported_parameters": [- "tool_choice",- "tools"- ]- },"xiaomi/mimo-v2-flash": {"id": "xiaomi/mimo-v2-flash","name": "Xiaomi: MiMo-V2-Flash",@@ -5936,7 +6376,7 @@"context_length": 262144,"max_output_tokens": 65536,"input_price_per_mtok": 0.22,- "output_price_per_mtok": 1.0,+ "output_price_per_mtok": 1.8,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -7996,34 +8436,6 @@"web_search_options"]},- "qwen/qwq-32b": {- "id": "qwen/qwq-32b",- "name": "Qwen: QwQ 32B",- "provider": "qwen",- "local_id": "qwq-32b",- "context_length": 131072,- "max_output_tokens": 131072,- "input_price_per_mtok": 0.15,- "output_price_per_mtok": 0.58,- "supports_thinking": false,- "thinking_type": "none",- "temperature_range": [- 0.0,- 2.0- ],- "is_reasoning_model": false,- "supported_parameters": [- "frequency_penalty",- "include_reasoning",- "max_tokens",- "reasoning",- "temperature",- "tool_choice",- "tools",- "top_k",- "top_p"- ]- },"gemini/gemini-2.0-flash-lite-001": {"id": "google/gemini-2.0-flash-lite-001","name": "Google: Gemini 2.0 Flash Lite",@@ -9293,11 +9705,11 @@"top_p"]},- "inflection/inflection-3-pi": {- "id": "inflection/inflection-3-pi",- "name": "Inflection: Inflection 3 Pi",+ "inflection/inflection-3-productivity": {+ "id": "inflection/inflection-3-productivity",+ "name": "Inflection: Inflection 3 Productivity","provider": "inflection",- "local_id": "inflection-3-pi",+ "local_id": "inflection-3-productivity","context_length": 8000,"max_output_tokens": 1024,"input_price_per_mtok": 2.5,@@ -9316,11 +9728,11 @@"top_p"]},- "inflection/inflection-3-productivity": {- "id": "inflection/inflection-3-productivity",- "name": "Inflection: Inflection 3 Productivity",+ "inflection/inflection-3-pi": {+ "id": "inflection/inflection-3-pi",+ "name": "Inflection: Inflection 3 Pi","provider": "inflection",- "local_id": "inflection-3-productivity",+ "local_id": "inflection-3-pi","context_length": 8000,"max_output_tokens": 1024,"input_price_per_mtok": 2.5,@@ -9375,15 +9787,15 @@"top_p"]},- "meta/llama-3.2-1b-instruct": {- "id": "meta-llama/llama-3.2-1b-instruct",- "name": "Meta: Llama 3.2 1B Instruct",+ "meta/llama-3.2-3b-instruct:free": {+ "id": "meta-llama/llama-3.2-3b-instruct:free",+ "name": "Meta: Llama 3.2 3B Instruct (free)","provider": "meta",- "local_id": "llama-3.2-1b-instruct",- "context_length": 60000,+ "local_id": "llama-3.2-3b-instruct:free",+ "context_length": 131072,"max_output_tokens": 0,- "input_price_per_mtok": 0.027,- "output_price_per_mtok": 0.2,+ "input_price_per_mtok": 0.0,+ "output_price_per_mtok": 0.0,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -9395,22 +9807,21 @@"frequency_penalty","max_tokens","presence_penalty",- "repetition_penalty",- "seed",+ "stop","temperature","top_k","top_p"]},- "meta/llama-3.2-11b-vision-instruct": {- "id": "meta-llama/llama-3.2-11b-vision-instruct",- "name": "Meta: Llama 3.2 11B Vision Instruct",+ "meta/llama-3.2-3b-instruct": {+ "id": "meta-llama/llama-3.2-3b-instruct",+ "name": "Meta: Llama 3.2 3B Instruct","provider": "meta",- "local_id": "llama-3.2-11b-vision-instruct",- "context_length": 131072,- "max_output_tokens": 16384,- "input_price_per_mtok": 0.245,- "output_price_per_mtok": 0.245,+ "local_id": "llama-3.2-3b-instruct",+ "context_length": 80000,+ "max_output_tokens": 0,+ "input_price_per_mtok": 0.051,+ "output_price_per_mtok": 0.34,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -9420,28 +9831,24 @@"is_reasoning_model": false,"supported_parameters": ["frequency_penalty",- "logit_bias","max_tokens",- "min_p","presence_penalty","repetition_penalty",- "response_format","seed",- "stop","temperature","top_k","top_p"]},- "meta/llama-3.2-3b-instruct:free": {- "id": "meta-llama/llama-3.2-3b-instruct:free",- "name": "Meta: Llama 3.2 3B Instruct (free)",+ "meta/llama-3.2-1b-instruct": {+ "id": "meta-llama/llama-3.2-1b-instruct",+ "name": "Meta: Llama 3.2 1B Instruct","provider": "meta",- "local_id": "llama-3.2-3b-instruct:free",- "context_length": 131072,+ "local_id": "llama-3.2-1b-instruct",+ "context_length": 60000,"max_output_tokens": 0,- "input_price_per_mtok": 0.0,- "output_price_per_mtok": 0.0,+ "input_price_per_mtok": 0.027,+ "output_price_per_mtok": 0.2,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -9453,21 +9860,22 @@"frequency_penalty","max_tokens","presence_penalty",- "stop",+ "repetition_penalty",+ "seed","temperature","top_k","top_p"]},- "meta/llama-3.2-3b-instruct": {- "id": "meta-llama/llama-3.2-3b-instruct",- "name": "Meta: Llama 3.2 3B Instruct",+ "meta/llama-3.2-11b-vision-instruct": {+ "id": "meta-llama/llama-3.2-11b-vision-instruct",+ "name": "Meta: Llama 3.2 11B Vision Instruct","provider": "meta",- "local_id": "llama-3.2-3b-instruct",- "context_length": 80000,- "max_output_tokens": 0,- "input_price_per_mtok": 0.051,- "output_price_per_mtok": 0.34,+ "local_id": "llama-3.2-11b-vision-instruct",+ "context_length": 131072,+ "max_output_tokens": 16384,+ "input_price_per_mtok": 0.245,+ "output_price_per_mtok": 0.245,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -9477,10 +9885,14 @@"is_reasoning_model": false,"supported_parameters": ["frequency_penalty",+ "logit_bias","max_tokens",+ "min_p","presence_penalty","repetition_penalty",+ "response_format","seed",+ "stop","temperature","top_k","top_p"@@ -9493,8 +9905,8 @@"local_id": "qwen-2.5-72b-instruct","context_length": 32768,"max_output_tokens": 16384,- "input_price_per_mtok": 0.12,- "output_price_per_mtok": 0.39,+ "input_price_per_mtok": 0.36,+ "output_price_per_mtok": 0.4,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -9520,15 +9932,15 @@"top_p"]},- "cohere/command-r-08-2024": {- "id": "cohere/command-r-08-2024",- "name": "Cohere: Command R (08-2024)",+ "cohere/command-r-plus-08-2024": {+ "id": "cohere/command-r-plus-08-2024",+ "name": "Cohere: Command R+ (08-2024)","provider": "cohere",- "local_id": "command-r-08-2024",+ "local_id": "command-r-plus-08-2024","context_length": 128000,"max_output_tokens": 4000,- "input_price_per_mtok": 0.15,- "output_price_per_mtok": 0.6,+ "input_price_per_mtok": 2.5,+ "output_price_per_mtok": 10.0,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -9551,15 +9963,15 @@"top_p"]},- "cohere/command-r-plus-08-2024": {- "id": "cohere/command-r-plus-08-2024",- "name": "Cohere: Command R+ (08-2024)",+ "cohere/command-r-08-2024": {+ "id": "cohere/command-r-08-2024",+ "name": "Cohere: Command R (08-2024)","provider": "cohere",- "local_id": "command-r-plus-08-2024",+ "local_id": "command-r-08-2024","context_length": 128000,"max_output_tokens": 4000,- "input_price_per_mtok": 2.5,- "output_price_per_mtok": 10.0,+ "input_price_per_mtok": 0.15,+ "output_price_per_mtok": 0.6,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -9773,15 +10185,15 @@"web_search_options"]},- "meta/llama-3.1-70b-instruct": {- "id": "meta-llama/llama-3.1-70b-instruct",- "name": "Meta: Llama 3.1 70B Instruct",+ "meta/llama-3.1-8b-instruct": {+ "id": "meta-llama/llama-3.1-8b-instruct",+ "name": "Meta: Llama 3.1 8B Instruct","provider": "meta",- "local_id": "llama-3.1-70b-instruct",- "context_length": 131072,+ "local_id": "llama-3.1-8b-instruct",+ "context_length": 16384,"max_output_tokens": 16384,- "input_price_per_mtok": 0.4,- "output_price_per_mtok": 0.4,+ "input_price_per_mtok": 0.02,+ "output_price_per_mtok": 0.05,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -9792,6 +10204,7 @@"supported_parameters": ["frequency_penalty","logit_bias",+ "logprobs","max_tokens","min_p","presence_penalty",@@ -9804,18 +10217,19 @@"tool_choice","tools","top_k",+ "top_logprobs","top_p"]},- "meta/llama-3.1-8b-instruct": {- "id": "meta-llama/llama-3.1-8b-instruct",- "name": "Meta: Llama 3.1 8B Instruct",+ "meta/llama-3.1-70b-instruct": {+ "id": "meta-llama/llama-3.1-70b-instruct",+ "name": "Meta: Llama 3.1 70B Instruct","provider": "meta",- "local_id": "llama-3.1-8b-instruct",- "context_length": 16384,+ "local_id": "llama-3.1-70b-instruct",+ "context_length": 131072,"max_output_tokens": 16384,- "input_price_per_mtok": 0.02,- "output_price_per_mtok": 0.05,+ "input_price_per_mtok": 0.4,+ "output_price_per_mtok": 0.4,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -9826,7 +10240,6 @@"supported_parameters": ["frequency_penalty","logit_bias",- "logprobs","max_tokens","min_p","presence_penalty",@@ -9839,7 +10252,6 @@"tool_choice","tools","top_k",- "top_logprobs","top_p"]},@@ -9850,7 +10262,7 @@"local_id": "mistral-nemo","context_length": 131072,"max_output_tokens": 0,- "input_price_per_mtok": 0.01,+ "input_price_per_mtok": 0.02,"output_price_per_mtok": 0.03,"supports_thinking": false,"thinking_type": "none",@@ -10107,15 +10519,15 @@"web_search_options"]},- "meta/llama-3-70b-instruct": {- "id": "meta-llama/llama-3-70b-instruct",- "name": "Meta: Llama 3 70B Instruct",+ "meta/llama-3-8b-instruct": {+ "id": "meta-llama/llama-3-8b-instruct",+ "name": "Meta: Llama 3 8B Instruct","provider": "meta",- "local_id": "llama-3-70b-instruct",+ "local_id": "llama-3-8b-instruct","context_length": 8192,- "max_output_tokens": 8000,- "input_price_per_mtok": 0.51,- "output_price_per_mtok": 0.74,+ "max_output_tokens": 16384,+ "input_price_per_mtok": 0.03,+ "output_price_per_mtok": 0.04,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -10125,25 +10537,30 @@"is_reasoning_model": false,"supported_parameters": ["frequency_penalty",+ "logit_bias","max_tokens",+ "min_p","presence_penalty","repetition_penalty",+ "response_format","seed","stop","temperature",+ "tool_choice",+ "tools","top_k","top_p"]},- "meta/llama-3-8b-instruct": {- "id": "meta-llama/llama-3-8b-instruct",- "name": "Meta: Llama 3 8B Instruct",+ "meta/llama-3-70b-instruct": {+ "id": "meta-llama/llama-3-70b-instruct",+ "name": "Meta: Llama 3 70B Instruct","provider": "meta",- "local_id": "llama-3-8b-instruct",+ "local_id": "llama-3-70b-instruct","context_length": 8192,- "max_output_tokens": 16384,- "input_price_per_mtok": 0.03,- "output_price_per_mtok": 0.04,+ "max_output_tokens": 8000,+ "input_price_per_mtok": 0.51,+ "output_price_per_mtok": 0.74,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -10153,17 +10570,12 @@"is_reasoning_model": false,"supported_parameters": ["frequency_penalty",- "logit_bias","max_tokens",- "min_p","presence_penalty","repetition_penalty",- "response_format","seed","stop","temperature",- "tool_choice",- "tools","top_k","top_p"]@@ -10315,15 +10727,15 @@"top_p"]},- "openai/gpt-3.5-turbo-0613": {- "id": "openai/gpt-3.5-turbo-0613",- "name": "OpenAI: GPT-3.5 Turbo (older v0613)",+ "openai/gpt-4-turbo-preview": {+ "id": "openai/gpt-4-turbo-preview",+ "name": "OpenAI: GPT-4 Turbo Preview","provider": "openai",- "local_id": "gpt-3.5-turbo-0613",- "context_length": 4095,+ "local_id": "gpt-4-turbo-preview",+ "context_length": 128000,"max_output_tokens": 4096,- "input_price_per_mtok": 1.0,- "output_price_per_mtok": 2.0,+ "input_price_per_mtok": 10.0,+ "output_price_per_mtok": 30.0,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -10335,7 +10747,7 @@"frequency_penalty","logit_bias","logprobs",- "max_completion_tokens",+ "max_tokens","presence_penalty","response_format","seed",@@ -10348,15 +10760,15 @@"top_p"]},- "openai/gpt-4-turbo-preview": {- "id": "openai/gpt-4-turbo-preview",- "name": "OpenAI: GPT-4 Turbo Preview",+ "openai/gpt-3.5-turbo-0613": {+ "id": "openai/gpt-3.5-turbo-0613",+ "name": "OpenAI: GPT-3.5 Turbo (older v0613)","provider": "openai",- "local_id": "gpt-4-turbo-preview",- "context_length": 128000,+ "local_id": "gpt-3.5-turbo-0613",+ "context_length": 4095,"max_output_tokens": 4096,- "input_price_per_mtok": 10.0,- "output_price_per_mtok": 30.0,+ "input_price_per_mtok": 1.0,+ "output_price_per_mtok": 2.0,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -10368,7 +10780,7 @@"frequency_penalty","logit_bias","logprobs",- "max_tokens",+ "max_completion_tokens","presence_penalty","response_format","seed",@@ -10522,15 +10934,15 @@"top_p"]},- "mistralai/mistral-7b-instruct-v0.1": {- "id": "mistralai/mistral-7b-instruct-v0.1",- "name": "Mistral: Mistral 7B Instruct v0.1",- "provider": "mistralai",- "local_id": "mistral-7b-instruct-v0.1",- "context_length": 2824,- "max_output_tokens": 0,- "input_price_per_mtok": 0.11,- "output_price_per_mtok": 0.19,+ "openai/gpt-3.5-turbo-instruct": {+ "id": "openai/gpt-3.5-turbo-instruct",+ "name": "OpenAI: GPT-3.5 Turbo Instruct",+ "provider": "openai",+ "local_id": "gpt-3.5-turbo-instruct",+ "context_length": 4095,+ "max_output_tokens": 4096,+ "input_price_per_mtok": 1.5,+ "output_price_per_mtok": 2.0,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -10540,24 +10952,28 @@"is_reasoning_model": false,"supported_parameters": ["frequency_penalty",+ "logit_bias",+ "logprobs","max_tokens","presence_penalty",- "repetition_penalty",+ "response_format","seed",+ "stop",+ "structured_outputs","temperature",- "top_k",+ "top_logprobs","top_p"]},- "openai/gpt-3.5-turbo-instruct": {- "id": "openai/gpt-3.5-turbo-instruct",- "name": "OpenAI: GPT-3.5 Turbo Instruct",- "provider": "openai",- "local_id": "gpt-3.5-turbo-instruct",- "context_length": 4095,- "max_output_tokens": 4096,- "input_price_per_mtok": 1.5,- "output_price_per_mtok": 2.0,+ "mistralai/mistral-7b-instruct-v0.1": {+ "id": "mistralai/mistral-7b-instruct-v0.1",+ "name": "Mistral: Mistral 7B Instruct v0.1",+ "provider": "mistralai",+ "local_id": "mistral-7b-instruct-v0.1",+ "context_length": 2824,+ "max_output_tokens": 0,+ "input_price_per_mtok": 0.11,+ "output_price_per_mtok": 0.19,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -10567,16 +10983,12 @@"is_reasoning_model": false,"supported_parameters": ["frequency_penalty",- "logit_bias",- "logprobs","max_tokens","presence_penalty",- "response_format",+ "repetition_penalty","seed",- "stop",- "structured_outputs","temperature",- "top_logprobs",+ "top_k","top_p"]},@@ -10718,15 +11130,15 @@"top_p"]},- "openai/gpt-3.5-turbo": {- "id": "openai/gpt-3.5-turbo",- "name": "OpenAI: GPT-3.5 Turbo",+ "openai/gpt-4-0314": {+ "id": "openai/gpt-4-0314",+ "name": "OpenAI: GPT-4 (older v0314)","provider": "openai",- "local_id": "gpt-3.5-turbo",- "context_length": 16385,+ "local_id": "gpt-4-0314",+ "context_length": 8191,"max_output_tokens": 4096,- "input_price_per_mtok": 0.5,- "output_price_per_mtok": 1.5,+ "input_price_per_mtok": 30.0,+ "output_price_per_mtok": 60.0,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -10751,11 +11163,11 @@"top_p"]},- "openai/gpt-4-0314": {- "id": "openai/gpt-4-0314",- "name": "OpenAI: GPT-4 (older v0314)",+ "openai/gpt-4": {+ "id": "openai/gpt-4",+ "name": "OpenAI: GPT-4","provider": "openai",- "local_id": "gpt-4-0314",+ "local_id": "gpt-4","context_length": 8191,"max_output_tokens": 4096,"input_price_per_mtok": 30.0,@@ -10771,6 +11183,7 @@"frequency_penalty","logit_bias","logprobs",+ "max_completion_tokens","max_tokens","presence_penalty","response_format",@@ -10784,15 +11197,15 @@"top_p"]},- "openai/gpt-4": {- "id": "openai/gpt-4",- "name": "OpenAI: GPT-4",+ "openai/gpt-3.5-turbo": {+ "id": "openai/gpt-3.5-turbo",+ "name": "OpenAI: GPT-3.5 Turbo","provider": "openai",- "local_id": "gpt-4",- "context_length": 8191,+ "local_id": "gpt-3.5-turbo",+ "context_length": 16385,"max_output_tokens": 4096,- "input_price_per_mtok": 30.0,- "output_price_per_mtok": 60.0,+ "input_price_per_mtok": 0.5,+ "output_price_per_mtok": 1.5,"supports_thinking": false,"thinking_type": "none","temperature_range": [@@ -10804,7 +11217,6 @@"frequency_penalty","logit_bias","logprobs",- "max_completion_tokens","max_tokens","presence_penalty","response_format",diff --git a/server/pyproject.toml b/server/pyproject.tomlindex efede1ec..2509b7f4 100644--- a/server/pyproject.toml+++ b/server/pyproject.toml@@ -43,14 +43,24 @@ dependencies = ["cryptography>=44.0.0",# AI - All providers (directly imported in ai.py)- "langchain-core>=0.3.0",- "langchain-openai>=0.2.0",- "langchain-anthropic>=0.3.0",- "langchain-google-genai>=2.0.0",- "langchain-groq>=0.2.0",- "langchain-cerebras>=0.1.0",- "langgraph>=0.2.0",- "deepagents>=0.4.12",+ # Versions pinned to exactly match the main branch so that the LangGraph+ # agent loop behaves identically. The `response.tool_calls` empty-payload+ # regression on tool_use responses appears to come from a library skew+ # somewhere in this set; lockstepping with main eliminates it as a+ # variable. Lift these pins when the upstream cause is identified.+ "langchain-core==1.2.28",+ "langchain-openai==1.1.12",+ "langchain-anthropic==1.4.0",+ "anthropic==0.94.0",+ "langchain-google-genai==4.2.1",+ "google-genai==1.72.0",+ "langchain-groq==1.1.2",+ "langchain-cerebras==0.8.2",+ "langgraph==1.1.6",+ "deepagents==0.5.2",+ # Pydantic 2.13 changed validator ordering; pin to main's 2.12 line+ # to keep AIMessage construction/tool-schema generation identical.+ "pydantic==2.12.5",# Dependency Injection"dependency-injector>=4.40.0",diff --git a/workflows/ai-employee-experimental.json b/workflows/ai-employee-experimental.jsondeleted file mode 100644index 69e6145b..00000000--- a/workflows/ai-employee-experimental.json+++ /dev/null@@ -1,1400 +0,0 @@-{- "id": "ai-employee-experimental",- "name": "AI Employee (Experimental)",- "nodes": [- {- "id": "orchestrator_agent-1772283239381",- "type": "orchestrator_agent",- "position": {- "x": -100,- "y": 900- },- "data": {- "label": "Orchestrator Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": -100,- "y": 900- },- "dragging": false- },- {- "id": "ai_employee-1772283240733",- "type": "ai_employee",- "position": {- "x": -440,- "y": 600- },- "data": {- "label": "AI Employee"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": -440,- "y": 600- },- "dragging": false- },- {- "id": "taskTrigger-1772283316801",- "type": "taskTrigger",- "position": {- "x": -960,- "y": 860- },- "data": {- "label": "Task Completed"- },- "width": 86,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -960,- "y": 860- },- "dragging": false- },- {- "id": "chatTrigger-1772283321856",- "type": "chatTrigger",- "position": {- "x": -960,- "y": 740- },- "data": {- "label": "Chat Trigger"- },- "width": 67,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -960,- "y": 740- },- "dragging": false- },- {- "id": "console-1772283322828",- "type": "console",- "position": {- "x": 120,- "y": 760- },- "data": {- "label": "Console"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 120,- "y": 760- },- "dragging": false- },- {- "id": "teamMonitor-1772283324318",- "type": "teamMonitor",- "position": {- "x": 300,- "y": 780- },- "data": {- "label": "Team Monitor"- },- "width": 76,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 300,- "y": 780- },- "dragging": true- },- {- "id": "simpleMemory-1772283375051",- "type": "simpleMemory",- "position": {- "x": -580,- "y": 880- },- "data": {- "label": "Simple Memory"- },- "width": 87,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -580,- "y": 880- },- "dragging": false- },- {- "id": "duckduckgoSearch-1772283377870",- "type": "duckduckgoSearch",- "position": {- "x": -540,- "y": 1520- },- "data": {- "label": "DuckDuckGo Search"- },- "width": 110,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -540,- "y": 1520- },- "dragging": false- },- {- "id": "masterSkill-1772283380072",- "type": "masterSkill",- "position": {- "x": -440,- "y": 880- },- "data": {- "label": "Master Skill"- },- "width": 63,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -440,- "y": 880- },- "dragging": false- },- {- "id": "taskManager-1772283382254",- "type": "taskManager",- "position": {- "x": -420,- "y": 1080- },- "data": {- "label": "Task Manager"- },- "width": 75,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -420,- "y": 1080- },- "dragging": true- },- {- "id": "coding_agent-1772286449045",- "type": "coding_agent",- "position": {- "x": 240,- "y": 1240- },- "data": {- "label": "Coding Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": 240,- "y": 1240- },- "dragging": false- },- {- "id": "web_agent-1772286450006",- "type": "web_agent",- "position": {- "x": -760,- "y": 1240- },- "data": {- "label": "Web Control Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": -760,- "y": 1240- },- "dragging": false- },- {- "id": "social_agent-1772286452768",- "type": "social_agent",- "position": {- "x": 720,- "y": 1240- },- "data": {- "label": "Social Media Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": 720,- "y": 1240- },- "dragging": false- },- {- "id": "productivity_agent-1772286457333",- "type": "productivity_agent",- "position": {- "x": -280,- "y": 1240- },- "data": {- "label": "Productivity Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": -280,- "y": 1240- },- "dragging": false- },- {- "id": "pythonExecutor-1772286519369",- "type": "pythonExecutor",- "position": {- "x": 440,- "y": 1520- },- "data": {- "label": "Python Executor"- },- "width": 89,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 440,- "y": 1520- },- "dragging": false- },- {- "id": "whatsappDb-1772286523527",- "type": "whatsappDb",- "position": {- "x": 920,- "y": 1520- },- "data": {- "label": "WhatsApp DB"- },- "width": 76,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 920,- "y": 1520- },- "dragging": false- },- {- "id": "perplexitySearch-1772286538579",- "type": "perplexitySearch",- "position": {- "x": -660,- "y": 1520- },- "data": {- "label": "Perplexity Search"- },- "width": 93,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -660,- "y": 1520- },- "dragging": false- },- {- "id": "gmail-1772286542794",- "type": "googleGmail",- "position": {- "x": -40,- "y": 1520- },- "data": {- "label": "Gmail"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -40,- "y": 1520- },- "dragging": false- },- {- "id": "sheets-1772286546873",- "type": "googleSheets",- "position": {- "x": -140,- "y": 1520- },- "data": {- "label": "Sheets"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -140,- "y": 1520- },- "dragging": false- },- {- "id": "masterSkill-1772286623655",- "type": "masterSkill",- "position": {- "x": -800,- "y": 1520- },- "data": {- "label": "Master Skill 1"- },- "width": 71,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -800,- "y": 1520- },- "dragging": false- },- {- "id": "masterSkill-1772286624787",- "type": "masterSkill",- "position": {- "x": -280,- "y": 1520- },- "data": {- "label": "Master Skill 2"- },- "width": 73,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -280,- "y": 1520- },- "dragging": false- },- {- "id": "masterSkill-1772286639206",- "type": "masterSkill",- "position": {- "x": 240,- "y": 1520- },- "data": {- "label": "Master Skill 3"- },- "width": 73,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 240,- "y": 1520- },- "dragging": true- },- {- "id": "masterSkill-1772286641708",- "type": "masterSkill",- "position": {- "x": 760,- "y": 1520- },- "data": {- "label": "Master Skill 4"- },- "width": 73,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 760,- "y": 1520- },- "dragging": false- },- {- "id": "simpleMemory-1772286654076",- "type": "simpleMemory",- "position": {- "x": -900,- "y": 1400- },- "data": {- "label": "Simple Memory 1"- },- "width": 95,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -900,- "y": 1400- },- "dragging": true- },- {- "id": "simpleMemory-1772286662040",- "type": "simpleMemory",- "position": {- "x": -400,- "y": 1420- },- "data": {- "label": "Simple Memory 2"- },- "width": 97,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -400,- "y": 1420- },- "dragging": false- },- {- "id": "simpleMemory-1772286667244",- "type": "simpleMemory",- "position": {- "x": 120,- "y": 1420- },- "data": {- "label": "Simple Memory 3"- },- "width": 97,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 120,- "y": 1420- },- "dragging": true- },- {- "id": "simpleMemory-1772286673234",- "type": "simpleMemory",- "position": {- "x": 600,- "y": 1400- },- "data": {- "label": "Simple Memory 4"- },- "width": 97,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 600,- "y": 1400- },- "dragging": true- },- {- "id": "simpleMemory-1772437660092",- "type": "simpleMemory",- "position": {- "x": -560,- "y": 1080- },- "data": {- "label": "Simple Memory 5"- },- "width": 97,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -560,- "y": 1080- },- "dragging": false- },- {- "id": "masterSkill-1772437683119",- "type": "masterSkill",- "position": {- "x": -280,- "y": 1080- },- "data": {- "label": "Master Skill 5"- },- "width": 73,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -280,- "y": 1080- },- "dragging": false- },- {- "id": "telegramReceive-1772718416883",- "type": "telegramReceive",- "position": {- "x": -980,- "y": 620- },- "data": {- "label": "Telegram Receive"- },- "width": 94,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": -980,- "y": 620- },- "dragging": false- },- {- "id": "telegramSend-1772781417360",- "type": "telegramSend",- "position": {- "x": 100,- "y": 640- },- "data": {- "label": "Telegram Send"- },- "width": 80,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 100,- "y": 640- },- "dragging": true- }- ],- "edges": [- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "chatTrigger-1772283321856",- "sourceHandle": "output-main",- "target": "ai_employee-1772283240733",- "targetHandle": "input-main",- "id": "reactflow__edge-chatTrigger-1772283321856output-main-ai_employee-1772283240733input-main",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "ai_employee-1772283240733",- "sourceHandle": "output-main",- "target": "console-1772283322828",- "targetHandle": "input-main",- "id": "reactflow__edge-ai_employee-1772283240733output-main-console-1772283322828input-main",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1772283375051",- "sourceHandle": "output-memory",- "target": "ai_employee-1772283240733",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1772283375051output-memory-ai_employee-1772283240733input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1772283380072",- "sourceHandle": "output-main",- "target": "ai_employee-1772283240733",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1772283380072output-main-ai_employee-1772283240733input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "orchestrator_agent-1772283239381",- "sourceHandle": "output-top",- "target": "ai_employee-1772283240733",- "targetHandle": "input-teammates",- "id": "reactflow__edge-orchestrator_agent-1772283239381output-top-ai_employee-1772283240733input-teammates",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "taskTrigger-1772283316801",- "sourceHandle": "output-main",- "target": "ai_employee-1772283240733",- "targetHandle": "input-task",- "id": "reactflow__edge-taskTrigger-1772283316801output-main-ai_employee-1772283240733input-task",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "web_agent-1772286450006",- "sourceHandle": "output-top",- "target": "orchestrator_agent-1772283239381",- "targetHandle": "input-teammates",- "id": "reactflow__edge-web_agent-1772286450006output-top-orchestrator_agent-1772283239381input-teammates",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "productivity_agent-1772286457333",- "sourceHandle": "output-top",- "target": "orchestrator_agent-1772283239381",- "targetHandle": "input-teammates",- "id": "reactflow__edge-productivity_agent-1772286457333output-top-orchestrator_agent-1772283239381input-teammates",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "coding_agent-1772286449045",- "sourceHandle": "output-top",- "target": "orchestrator_agent-1772283239381",- "targetHandle": "input-teammates",- "id": "reactflow__edge-coding_agent-1772286449045output-top-orchestrator_agent-1772283239381input-teammates",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "social_agent-1772286452768",- "sourceHandle": "output-top",- "target": "orchestrator_agent-1772283239381",- "targetHandle": "input-teammates",- "id": "reactflow__edge-social_agent-1772286452768output-top-orchestrator_agent-1772283239381input-teammates",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "sheets-1772286546873",- "sourceHandle": "output-tool",- "target": "productivity_agent-1772286457333",- "targetHandle": "input-tools",- "id": "reactflow__edge-sheets-1772286546873output-tool-productivity_agent-1772286457333input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "whatsappDb-1772286523527",- "sourceHandle": "output-tool",- "target": "social_agent-1772286452768",- "targetHandle": "input-tools",- "id": "reactflow__edge-whatsappDb-1772286523527output-tool-social_agent-1772286452768input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "perplexitySearch-1772286538579",- "sourceHandle": "output-tool",- "target": "web_agent-1772286450006",- "targetHandle": "input-tools",- "id": "reactflow__edge-perplexitySearch-1772286538579output-tool-web_agent-1772286450006input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "pythonExecutor-1772286519369",- "sourceHandle": "output-tool",- "target": "coding_agent-1772286449045",- "targetHandle": "input-tools",- "id": "reactflow__edge-pythonExecutor-1772286519369output-tool-coding_agent-1772286449045input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "gmail-1772286542794",- "sourceHandle": "output-tool",- "target": "productivity_agent-1772286457333",- "targetHandle": "input-tools",- "id": "reactflow__edge-gmail-1772286542794output-tool-productivity_agent-1772286457333input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1772286623655",- "sourceHandle": "output-main",- "target": "web_agent-1772286450006",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1772286623655output-main-web_agent-1772286450006input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1772286624787",- "sourceHandle": "output-main",- "target": "productivity_agent-1772286457333",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1772286624787output-main-productivity_agent-1772286457333input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1772286641708",- "sourceHandle": "output-main",- "target": "social_agent-1772286452768",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1772286641708output-main-social_agent-1772286452768input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1772286639206",- "sourceHandle": "output-main",- "target": "coding_agent-1772286449045",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1772286639206output-main-coding_agent-1772286449045input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1772286654076",- "sourceHandle": "output-memory",- "target": "web_agent-1772286450006",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1772286654076output-memory-web_agent-1772286450006input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1772286662040",- "sourceHandle": "output-memory",- "target": "productivity_agent-1772286457333",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1772286662040output-memory-productivity_agent-1772286457333input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1772286667244",- "sourceHandle": "output-memory",- "target": "coding_agent-1772286449045",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1772286667244output-memory-coding_agent-1772286449045input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1772286673234",- "sourceHandle": "output-memory",- "target": "social_agent-1772286452768",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1772286673234output-memory-social_agent-1772286452768input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "duckduckgoSearch-1772283377870",- "sourceHandle": "output-tool",- "target": "web_agent-1772286450006",- "targetHandle": "input-tools",- "id": "reactflow__edge-duckduckgoSearch-1772283377870output-tool-web_agent-1772286450006input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "taskManager-1772283382254",- "sourceHandle": "output-tool",- "target": "orchestrator_agent-1772283239381",- "targetHandle": "input-tools",- "id": "reactflow__edge-taskManager-1772283382254output-tool-orchestrator_agent-1772283239381input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1772437660092",- "sourceHandle": "output-memory",- "target": "orchestrator_agent-1772283239381",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1772437660092output-memory-orchestrator_agent-1772283239381input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1772437683119",- "sourceHandle": "output-main",- "target": "orchestrator_agent-1772283239381",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1772437683119output-main-orchestrator_agent-1772283239381input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "telegramReceive-1772718416883",- "sourceHandle": "output-main",- "target": "ai_employee-1772283240733",- "targetHandle": "input-main",- "id": "reactflow__edge-telegramReceive-1772718416883output-main-ai_employee-1772283240733input-main",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "ai_employee-1772283240733",- "sourceHandle": "output-main",- "target": "telegramSend-1772781417360",- "targetHandle": "input-main",- "id": "reactflow__edge-ai_employee-1772283240733output-main-telegramSend-1772781417360input-main",- "selected": false- }- ],- "createdAt": "2026-03-06T01:21:30.885Z",- "lastModified": "2026-03-06T01:47:43.000Z",- "version": "0.0.43",- "nodeParameters": {- "orchestrator_agent-1772283239381": {- "provider": "openai",- "model": "gpt-5.2",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant",- "teamMode": "parallel",- "label": "Orchestrator Agent"- },- "ai_employee-1772283240733": {- "provider": "openai",- "model": "gpt-5.2",- "prompt": "{{chattrigger.message}} {{telegramreceive.text}}",- "systemMessage": "You are a helpful assistant",- "teamMode": "parallel",- "maxConcurrent": 5,- "label": "AI Employee"- },- "taskTrigger-1772283316801": {- "task_id": "",- "agent_name": "",- "status_filter": "all",- "parent_node_id": "",- "label": "Task Completed"- },- "chatTrigger-1772283321856": {- "sessionId": "default",- "placeholder": "Type a message...",- "label": "Chat Trigger"- },- "console-1772283322828": {- "label": "Console",- "logMode": "field",- "fieldPath": "{{aiemployee.data}}",- "expression": "",- "format": "json"- },- "teamMonitor-1772283324318": {- "refreshInterval": 1000,- "showTaskHistory": true,- "showMessages": true,- "maxHistoryItems": 50,- "label": "Team Monitor"- },- "simpleMemory-1772283375051": {- "sessionId": "",- "windowSize": 100,- "longTermEnabled": false,- "retrievalCount": 3,- "label": "Simple Memory"- },- "duckduckgoSearch-1772283377870": {- "toolName": "web_search",- "toolDescription": "Search the web for information. Returns relevant search results.",- "maxResults": 5,- "label": "DuckDuckGo Search"- },- "masterSkill-1772283380072": {- "skillFolder": "autonomous",- "skillsConfig": {- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "agentic-loop-skill": {- "enabled": true,- "instructions": "# Agentic Loop Pattern\n\nYou are an autonomous agent capable of iterative problem-solving through self-delegation and reflection.\n\n## Core Loop Structure\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ AGENTIC LOOP │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ OBSERVE ──▶ THINK ──▶ ACT ──▶ REFLECT ──▶ DECIDE │\n│ ▲ │ │\n│ │ │ │\n│ └──────────── (if not done) ◀──────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n### Step Details\n\n1. **OBSERVE**: What is the current state?\n - What data do I have?\n - What has been accomplished?\n - What constraints exist?\n\n2. **THINK**: What should I do next?\n - What is the immediate goal?\n - What's the best action to take?\n - What could go wrong?\n\n3. **ACT**: Execute ONE focused action\n - Generate code for computation\n - Call a specific tool\n - Delegate to a specialized agent\n\n4. **REFLECT**: Did it work?\n - Was the action successful?\n - What did I learn?\n - How does this change the state?\n\n5. **DECIDE**: Continue or complete?\n - Is the goal achieved? -> Complete and return\n - More work needed? -> Continue loop\n - Error occurred? -> Handle or escalate\n\n## Self-Delegation Pattern\n\nTo iterate on complex tasks, delegate to yourself with updated context:\n\n```json\n{\n \"task\": \"Continue: [specific next step description]\",\n \"context\": \"Iteration: 2/5\\nPrevious result: [summary]\\nCurrent state: [state]\\nRemaining: [what's left to do]\"\n}\n```\n\n### Context String Template\n\n```\nIteration: {current}/{max}\nGoal: {original goal}\nProgress: {what has been accomplished}\nState: {current data/results}\nErrors: {any errors encountered}\nNext: {specific next action}\n```\n\n## Example: Multi-Step Research Task\n\n**Task**: \"Research the top 3 programming languages of 2024, compare their use cases\"\n\n### Iteration 1: Gather Data\n```json\n{\n \"task\": \"Continue: Search for programming language rankings\",\n \"context\": \"Iteration: 1/4\\nGoal: Compare top 3 programming languages\\nProgress: Starting research\\nNext: Use web_search to find current rankings\"\n}\n```\nAction: Use web_search tool\nResult: Found TIOBE index - Python, C, C++\n\n### Iteration 2: Deep Dive on First Language\n```json\n{\n \"task\": \"Continue: Research Python use cases\",\n \"context\": \"Iteration: 2/4\\nGoal: Compare top 3 programming languages\\nProgress: Identified top 3 (Python, C, C++)\\nState: Rankings found\\nNext: Research Python use cases\"\n}\n```\nAction: Use web_search for Python applications\nResult: AI/ML, web development, automation, data science\n\n### Iteration 3: Research Remaining Languages\n```json\n{\n \"task\": \"Continue: Research C and C++ use cases\",\n \"context\": \"Iteration: 3/4\\nGoal: Compare top 3 programming languages\\nProgress: Python use cases complete\\nState: Python = AI/ML, web, automation\\nNext: Research C and C++ use cases\"\n}\n```\nAction: Use web_search for C/C++ applications\nResult: Systems programming, embedded, games, performance-critical\n\n### Iteration 4: Synthesize and Report\n```json\n{\n \"task\": \"Continue: Create comparison summary\",\n \"context\": \"Iteration: 4/4\\nGoal: Compare top 3 programming languages\\nProgress: All research complete\\nState: Python=AI/ML/Web, C=Systems/Embedded, C++=Games/Performance\\nNext: Generate final comparison\"\n}\n```\nAction: Generate comprehensive comparison\nResult: Complete comparison delivered to user\n\n## Stop Conditions\n\n**STOP and return when:**\n- Goal is achieved\n- Max iterations reached (default: 5)\n- Unrecoverable error encountered\n- User cancellation received\n- Diminishing returns (same result twice)\n\n**CONTINUE when:**\n- Progress is being made\n- More steps clearly needed\n- Recoverable error (can retry differently)\n\n## State Management Best Practices\n\n### DO:\n- Include iteration count in every delegation\n- Summarize previous results (not full data)\n- Be specific about the next action\n- Track accumulated state across iterations\n\n### DON'T:\n- Include massive data blobs in context\n- Forget to update iteration count\n- Lose track of the original goal\n- Continue indefinitely without progress\n\n## Example: Iterative Calculation\n\n**Task**: \"Calculate fibonacci(50) and factorize it\"\n\n### Iteration 1: Calculate Fibonacci\n```python\n# Use code mode for computation\ndef fib(n):\n a, b = 0, 1\n for _ in range(n):\n a, b = b, a + b\n return a\n\nresult = fib(50)\nprint(f\"Fibonacci(50) = {result}\")\n# Result: 12586269025\n```\n\n### Iteration 2: Factorize\n```json\n{\n \"task\": \"Continue: Factorize the fibonacci result\",\n \"context\": \"Iteration: 2/3\\nGoal: Calculate and factorize fib(50)\\nProgress: fib(50) = 12586269025\\nNext: Find prime factors\"\n}\n```\n\n```python\ndef factorize(n):\n factors = []\n d = 2\n while d * d <= n:\n while n % d == 0:\n factors.append(d)\n n //= d\n d += 1\n if n > 1:\n factors.append(n)\n return factors\n\nn = 12586269025\nfactors = factorize(n)\nprint(f\"Prime factors: {factors}\")\nprint(f\"Verification: {eval('*'.join(map(str, factors)))}\")\n```\n\n### Iteration 3: Summarize\nFinal response to user with both results\n\n## Integration with Task Trigger\n\nWhen using self-delegation:\n1. Your delegation creates a background task\n2. Task completes and fires `task_completed` event\n3. Task Trigger node catches the event\n4. Result is injected into your next prompt\n5. You continue with the result\n\nThis enables visual tracking of the loop in the workflow canvas.\n\n## Error Recovery in Loops\n\nIf an iteration fails:\n```json\n{\n \"task\": \"Retry: [same task with different approach]\",\n \"context\": \"Iteration: 2/5 (retry 1)\\nGoal: [original goal]\\nProgress: [what worked]\\nError: [what failed and why]\\nNew approach: [different strategy]\"\n}\n```\n\n## Anti-Patterns to Avoid\n\n1. **Infinite loops** - Always track iteration count\n2. **Lost context** - Always include previous results\n3. **Redundant work** - Check if step already done\n4. **Unclear goals** - State what \"done\" means clearly\n5. **Giant context** - Summarize, don't copy everything\n6. **No progress check** - Verify each step advanced the goal\n",- "isCustomized": false- },- "multi-tool-orchestration-skill": {- "enabled": true,- "instructions": "# Multi-Tool Orchestration Pattern\n\nYou are an agent skilled at coordinating multiple tools together to accomplish complex tasks that require combining different capabilities.\n\n## Why Multi-Tool Orchestration?\n\nComplex real-world tasks often require multiple tools working together:\n- **Data gathering** (web_search, http_request) + **Processing** (python_code) + **Delivery** (whatsapp_send)\n- **Time awareness** (current_time) + **Calculation** (calculator) + **Scheduling** (scheduler)\n- **Location** (gmaps) + **Communication** (social_send) + **Memory** (memory)\n\n## Orchestration Patterns\n\n### Pattern 1: Sequential Pipeline\n\nTools execute in order, each passing results to the next:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ SEQUENTIAL PIPELINE │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ [web_search] ──▶ [python_code] ──▶ [whatsapp_send] │\n│ │ │ │ │\n│ │ │ │ │\n│ \"Find stock \"Calculate \"Send summary │\n│ prices\" average\" to user\" │\n│ │ │ │ │\n│ ▼ ▼ ▼ │\n│ Raw data ──────▶ Processed ──────▶ Delivered │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n#### Example: Stock Price Alert\n\n**Task**: \"Get the current prices of AAPL, GOOGL, and MSFT, calculate the average, and send me a WhatsApp message with the results\"\n\n**Orchestration Steps:**\n\n1. **Gather Data** (web_search):\n```json\n{\"tool\": \"web_search\", \"query\": \"AAPL GOOGL MSFT stock price today\"}\n```\n\n2. **Process Data** (python_code):\n```python\nimport json\n\n# Data from previous step\nprices = {\"AAPL\": 185.50, \"GOOGL\": 141.25, \"MSFT\": 378.90}\n\n# Calculate statistics\naverage = sum(prices.values()) / len(prices)\nhighest = max(prices.items(), key=lambda x: x[1])\nlowest = min(prices.items(), key=lambda x: x[1])\n\noutput = {\n \"prices\": prices,\n \"average\": round(average, 2),\n \"highest\": {\"symbol\": highest[0], \"price\": highest[1]},\n \"lowest\": {\"symbol\": lowest[0], \"price\": lowest[1]},\n \"summary\": f\"Average: ${average:.2f} | High: {highest[0]} | Low: {lowest[0]}\"\n}\nprint(json.dumps(output, indent=2))\n```\n\n3. **Deliver Result** (whatsapp_send):\n```json\n{\n \"tool\": \"whatsapp_send\",\n \"recipient\": \"user\",\n \"message\": \"Stock Update:\\n- AAPL: $185.50\\n- GOOGL: $141.25\\n- MSFT: $378.90\\n\\nAverage: $235.22\"\n}\n```\n\n### Pattern 2: Parallel Gather, Sequential Process\n\nGather data from multiple sources simultaneously, then process together:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ PARALLEL GATHER + SEQUENTIAL PROCESS │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ [web_search: weather] ──────┐ │\n│ │ │\n│ [web_search: news] ─────────┼──▶ [python_code] ──▶ Output │\n│ │ \"Combine & │\n│ [current_time] ─────────────┘ Format\" │\n│ │\n│ All three run independently, results combined │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n#### Example: Daily Briefing\n\n**Task**: \"Create a morning briefing with weather, top news, and today's schedule\"\n\n**Orchestration:**\n\n```python\nimport json\nfrom datetime import datetime\n\n# Results from parallel tool calls (simulated)\nweather_data = {\"temp\": 72, \"condition\": \"Sunny\", \"high\": 78, \"low\": 65}\nnews_data = [\n {\"title\": \"Tech stocks rally\", \"source\": \"Reuters\"},\n {\"title\": \"New AI breakthrough\", \"source\": \"TechCrunch\"}\n]\ncurrent_time = datetime.now()\n\n# Combine into briefing\nbriefing = {\n \"date\": current_time.strftime(\"%A, %B %d, %Y\"),\n \"time\": current_time.strftime(\"%I:%M %p\"),\n \"weather\": {\n \"summary\": f\"{weather_data['condition']}, {weather_data['temp']}F\",\n \"range\": f\"High: {weather_data['high']}F, Low: {weather_data['low']}F\"\n },\n \"news\": [f\"- {n['title']} ({n['source']})\" for n in news_data],\n \"formatted\": None\n}\n\n# Create formatted output\nbriefing[\"formatted\"] = f\"\"\"\nGood Morning! {briefing['date']}\n\nWEATHER\n{briefing['weather']['summary']}\n{briefing['weather']['range']}\n\nTOP NEWS\n{chr(10).join(briefing['news'])}\n\"\"\"\n\nprint(json.dumps(briefing, indent=2))\n```\n\n### Pattern 3: Conditional Branching\n\nChoose different tools based on intermediate results:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ CONDITIONAL BRANCHING │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ [initial_check] │\n│ │ │\n│ ┌───────────┼───────────┐ │\n│ ▼ ▼ ▼ │\n│ Condition A Condition B Condition C │\n│ │ │ │ │\n│ ▼ ▼ ▼ │\n│ [tool_A] [tool_B] [tool_C] │\n│ │ │ │ │\n│ └───────────┼───────────┘ │\n│ ▼ │\n│ [final_tool] │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n#### Example: Smart Communication\n\n**Task**: \"Contact John with the meeting update - use the best available channel\"\n\n**Orchestration Logic:**\n```\n1. CHECK availability:\n - Is John online on WhatsApp? → Use whatsapp_send\n - Is John's email available? → Use email (via http_request)\n - Neither? → Schedule reminder for later\n\n2. EXECUTE chosen channel\n\n3. CONFIRM delivery status\n```\n\n### Pattern 4: Iterative Refinement\n\nUse tool results to improve subsequent tool calls:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ ITERATIVE REFINEMENT │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ [web_search v1] ──▶ [python_code: analyze] │\n│ │ │ │\n│ │ \"Results incomplete\" │\n│ │ │ │\n│ │ ▼ │\n│ │ [web_search v2] │\n│ │ (refined query) │\n│ │ │ │\n│ │ \"Results better\" │\n│ │ │ │\n│ └──────────────────────┼──▶ [python_code: combine] │\n│ │ │\n│ ▼ │\n│ Final Result │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n#### Example: Research Task\n\n**Task**: \"Find comprehensive information about quantum computing applications in finance\"\n\n**Iteration 1:**\n```json\n{\"tool\": \"web_search\", \"query\": \"quantum computing finance applications\"}\n```\nResult: General overview, but missing specific use cases\n\n**Iteration 2 (refined):**\n```json\n{\"tool\": \"web_search\", \"query\": \"quantum computing portfolio optimization risk analysis\"}\n```\nResult: Specific applications found\n\n**Combine with Code:**\n```python\nimport json\n\n# Results from both searches\nsearch_1 = [\"Overview of quantum finance\", \"Major players\"]\nsearch_2 = [\"Portfolio optimization algorithms\", \"Risk modeling with qubits\"]\n\ncombined = {\n \"topic\": \"Quantum Computing in Finance\",\n \"general\": search_1,\n \"specific_applications\": search_2,\n \"summary\": \"Quantum computing in finance focuses on portfolio optimization and risk analysis...\"\n}\nprint(json.dumps(combined, indent=2))\n```\n\n## Complex Multi-Tool Examples\n\n### Example 1: Travel Planning Assistant\n\n**Task**: \"Plan a trip from New York to San Francisco next week, find hotels, and send me an itinerary\"\n\n**Tools Used**: `current_time`, `web_search`, `python_code`, `whatsapp_send`\n\n**Orchestration:**\n\n```\nStep 1: Get current date (current_time)\n ↓\nStep 2: Calculate \"next week\" dates (python_code)\n ↓\nStep 3: Search for flights (web_search: \"NYC to SFO flights [dates]\")\n ↓\nStep 4: Search for hotels (web_search: \"San Francisco hotels [dates]\")\n ↓\nStep 5: Combine and format itinerary (python_code)\n ↓\nStep 6: Send to user (whatsapp_send)\n```\n\n**Code for Step 5:**\n```python\nimport json\nfrom datetime import datetime, timedelta\n\n# Inputs from previous steps\ntoday = datetime.now()\ntrip_start = today + timedelta(days=7)\ntrip_end = trip_start + timedelta(days=3)\n\nflights = [\n {\"airline\": \"United\", \"departure\": \"8:00 AM\", \"price\": \"$350\"},\n {\"airline\": \"Delta\", \"departure\": \"11:30 AM\", \"price\": \"$380\"}\n]\n\nhotels = [\n {\"name\": \"Marriott Union Square\", \"price\": \"$250/night\", \"rating\": 4.5},\n {\"name\": \"Hilton Financial District\", \"price\": \"$280/night\", \"rating\": 4.3}\n]\n\nitinerary = {\n \"trip\": {\n \"from\": \"New York (JFK)\",\n \"to\": \"San Francisco (SFO)\",\n \"dates\": f\"{trip_start.strftime('%b %d')} - {trip_end.strftime('%b %d, %Y')}\"\n },\n \"recommended_flight\": flights[0],\n \"recommended_hotel\": hotels[0],\n \"estimated_total\": \"$1,100\",\n \"formatted_message\": f\"\"\"\nTravel Itinerary: NYC → SFO\n\nDATES\n{trip_start.strftime('%b %d')} - {trip_end.strftime('%b %d, %Y')}\n\nFLIGHT (Recommended)\n{flights[0]['airline']} - {flights[0]['departure']} - {flights[0]['price']}\n\nHOTEL (Recommended)\n{hotels[0]['name']}\n{hotels[0]['price']} | Rating: {hotels[0]['rating']}/5\n\nESTIMATED TOTAL: $1,100\n\"\"\"\n}\n\nprint(json.dumps(itinerary, indent=2))\n```\n\n### Example 2: Automated Report Generation\n\n**Task**: \"Generate a weekly sales report with charts and email it to the team\"\n\n**Tools Used**: `http_request` (API), `python_code`, `http_request` (email)\n\n**Orchestration:**\n\n```\nStep 1: Fetch sales data from API (http_request)\n ↓\nStep 2: Process and analyze data (python_code)\n ↓\nStep 3: Generate text summary (python_code)\n ↓\nStep 4: Format as HTML report (python_code)\n ↓\nStep 5: Send via email API (http_request)\n```\n\n### Example 3: Smart Home Automation\n\n**Task**: \"When I get home, turn on the lights, set temperature to 72F, and play my evening playlist\"\n\n**Tools Used**: `location`, `http_request` (smart home API), `python_code`\n\n**Orchestration:**\n\n```\nStep 1: Check current location (location tool)\n ↓\nStep 2: Calculate distance to home (python_code)\n ↓\nStep 3: If within 1 mile:\n ├── Turn on lights (http_request to smart home API)\n ├── Set thermostat (http_request to smart home API)\n └── Start playlist (http_request to music API)\n ↓\nStep 4: Confirm all actions (python_code)\n```\n\n## Orchestration with Delegation\n\nFor complex multi-tool tasks, delegate sub-tasks to yourself:\n\n```json\n{\n \"task\": \"Continue: Execute delivery phase of travel planning\",\n \"context\": \"Iteration: 3/4\nPrevious: Gathered flight and hotel data\nCurrent state: Itinerary formatted and ready\nData: {flight: United $350, hotel: Marriott $250/night}\nNext: Send itinerary via WhatsApp and confirm delivery\"\n}\n```\n\n## Tool Combination Matrix\n\n| Task Type | Primary Tools | Supporting Tools |\n|-----------|--------------|------------------|\n| **Research** | web_search, http_request | python_code (analysis) |\n| **Calculation** | calculator, python_code | current_time |\n| **Communication** | whatsapp_send, http_request | python_code (formatting) |\n| **Scheduling** | current_time, calculator | python_code (date math) |\n| **Data Processing** | python_code, javascript_code | http_request (APIs) |\n| **Location-based** | gmaps, location | python_code, whatsapp_send |\n\n## Best Practices\n\n### 1. Plan Before Executing\n```\nBefore calling tools, outline:\n1. What data do I need?\n2. What tools provide that data?\n3. What order should they run?\n4. How will results combine?\n```\n\n### 2. Minimize Tool Calls\n```\nBAD: web_search(\"AAPL price\") → web_search(\"GOOGL price\") → web_search(\"MSFT price\")\nGOOD: web_search(\"AAPL GOOGL MSFT stock prices today\")\n```\n\n### 3. Use Code for Complex Logic\n```\nInstead of multiple calculator calls:\ncalculator(10 * 5) → calculator(50 + 20) → calculator(70 / 2)\n\nUse python_code:\nresult = ((10 * 5) + 20) / 2 # Single execution\n```\n\n### 4. Pass Context Between Tools\n```\nTool 1 output: {\"temperature\": 72, \"unit\": \"F\"}\nTool 2 input: Use the temperature (72F) in the message\n```\n\n### 5. Handle Partial Failures\n```\nIf tool 2 of 4 fails:\n- Continue with remaining tools if possible\n- Use partial data from successful tools\n- Report what succeeded and what failed\n```\n\n## Anti-Patterns\n\n### 1. Serial When Parallel is Possible\n```\n// Unnecessary waiting\nawait web_search(\"weather\")\nawait web_search(\"news\") // Could run in parallel\nawait web_search(\"stocks\") // Could run in parallel\n```\n\n### 2. Over-Orchestration\n```\n// Don't use 5 tools when 1 suffices\nTask: \"What's 2 + 2?\"\nBAD: current_time → python_code → calculator → format → return\nGOOD: calculator(2 + 2) or just respond \"4\"\n```\n\n### 3. Ignoring Tool Results\n```\n// Always use the actual results\nBAD: Call web_search, ignore result, make up answer\nGOOD: Call web_search, process result, return based on actual data\n```\n",- "isCustomized": false- },- "progressive-discovery-skill": {- "enabled": true,- "instructions": "# Progressive Tool Discovery\n\nYou are an agent that discovers and uses capabilities progressively as needed, rather than loading everything upfront.\n\n## Why Progressive Discovery?\n\nLoading all tools at start creates:\n- **Token overhead**: 150,000+ tokens for tool definitions\n- **Context pollution**: Irrelevant tools confuse the LLM\n- **Slower responses**: More tokens = more processing time\n\nProgressive discovery provides:\n- **98.7% token savings** (Anthropic MCP research)\n- **Focused context**: Only relevant tools loaded\n- **Better decisions**: Less noise, clearer choices\n\n## Discovery Pattern\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ PROGRESSIVE DISCOVERY │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ 1. START with minimal context │\n│ │ │\n│ ▼ │\n│ 2. IDENTIFY what capability is needed │\n│ │ │\n│ ▼ │\n│ 3. CHECK what tools/agents are connected │\n│ │ │\n│ ├──▶ Tool exists? ──▶ USE it directly │\n│ │ │\n│ └──▶ Specialized agent exists? ──▶ DELEGATE to it │\n│ │\n│ 4. EXECUTE with focused context │\n│ │ │\n│ ▼ │\n│ 5. RETURN result (don't load more than needed) │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n## Available Specialized Agents\n\nCheck your connected tools - you may have access to these specialized agents:\n\n| Agent | Capabilities | When to Delegate |\n|-------|--------------|------------------|\n| `android_agent` | Device control, apps, sensors | Android device tasks |\n| `coding_agent` | Python/JavaScript execution | Code computation |\n| `web_agent` | Web scraping, HTTP requests | Internet data |\n| `task_agent` | Scheduling, timers, cron | Time-based tasks |\n| `social_agent` | WhatsApp, messaging | Communication |\n| `travel_agent` | Maps, locations, directions | Travel planning |\n\n## Discovery Examples\n\n### Example 1: User asks \"What's the battery level?\"\n\n**Without Progressive Discovery** (wasteful):\n```\nLoad ALL tools (calculator, web_search, whatsapp, android, maps, code, ...)\nParse user request\nFind that android tool is needed\nExecute battery check\n```\n\n**With Progressive Discovery** (efficient):\n```\n1. IDENTIFY: This needs Android device access\n2. CHECK: Is android_agent or battery tool connected?\n3. YES → Delegate: \"Check battery level\"\n4. RETURN: Battery at 75%, charging\n```\n\n### Example 2: User asks \"Calculate compound interest for $10,000 at 5% for 10 years\"\n\n**Discovery Process:**\n```\n1. IDENTIFY: This is a mathematical calculation\n2. CHECK: Do I have python_code or calculator tool?\n\n IF python_code connected:\n Use Code Mode for complex calculation\n\n ELIF calculator connected:\n Use calculator for simple operations\n\n ELSE:\n Report: \"I need a code executor or calculator to compute this\"\n```\n\n### Example 3: User asks \"Send my location to John on WhatsApp\"\n\n**Discovery Process:**\n```\n1. IDENTIFY: Needs location + messaging\n2. CHECK: What's connected?\n\n Step A - Get location:\n IF location tool connected → Use directly\n ELIF android_agent connected → Delegate location request\n ELSE → Ask user for location\n\n Step B - Send message:\n IF whatsapp_send connected → Use directly\n ELIF social_agent connected → Delegate message\n ELSE → Report: \"WhatsApp not available\"\n```\n\n## Delegation Pattern\n\nWhen delegating to a specialized agent:\n\n```json\n{\n \"task\": \"Specific task description\",\n \"context\": \"Relevant context only (not everything)\"\n}\n```\n\n**Good Context** (focused):\n```json\n{\n \"task\": \"Get current GPS coordinates\",\n \"context\": \"User needs their location for a WhatsApp message\"\n}\n```\n\n**Bad Context** (bloated):\n```json\n{\n \"task\": \"Get current GPS coordinates\",\n \"context\": \"Full conversation history... user preferences... all previous results... system info...\"\n}\n```\n\n## Capability Check Pattern\n\nBefore attempting an action, verify the capability exists:\n\n```\nIF task requires capability X:\n\n IF direct_tool_for_X is connected:\n → Use tool directly (fastest)\n\n ELIF specialized_agent_for_X is connected:\n → Delegate to agent (handles complexity)\n\n ELSE:\n → Report: \"This capability is not available\"\n → Suggest: \"Connect [tool/agent name] to enable this\"\n```\n\n## Anti-Patterns to Avoid\n\n### 1. Loading Everything Upfront\n```\n❌ \"Let me check all my tools: calculator, web_search, whatsapp,\n android, maps, code, http, scheduler, memory...\"\n\n✓ \"To answer this, I need [specific capability]\"\n```\n\n### 2. Delegating Without Checking\n```\n❌ Immediately delegate to android_agent without checking if connected\n\n✓ Check connected tools first, then delegate if available\n```\n\n### 3. Over-Explaining Capabilities\n```\n❌ \"I have access to many tools including... [lists everything]\"\n\n✓ \"I can help with that. Let me [specific action].\"\n```\n\n### 4. Redundant Delegation\n```\n❌ Delegate \"calculate 2+2\" to coding_agent\n\n✓ Simple math can be done directly or with calculator tool\n```\n\n## Integration with Agentic Loop\n\nProgressive Discovery works with the Agentic Loop pattern:\n\n```\nOBSERVE: What does the user need?\n ↓\nTHINK: What capability is required?\n ↓\nDISCOVER: Is that capability connected?\n ↓\nACT: Use tool directly OR delegate to agent\n ↓\nREFLECT: Did it work?\n ↓\nDECIDE: Complete or discover next capability\n```\n\n## Best Practices\n\n1. **Start minimal** - Don't enumerate all tools at the start\n2. **Discover on demand** - Only check for capabilities when needed\n3. **Prefer direct tools** - Use connected tools before delegating\n4. **Focused delegation** - Pass only relevant context to agents\n5. **Report gaps clearly** - If capability missing, say what's needed\n",- "isCustomized": false- },- "code-mode-skill": {- "enabled": true,- "instructions": "# Code Mode Pattern\n\nYou are a Code Mode agent. Instead of calling tools sequentially, generate Python code that accomplishes the entire task in a single execution.\n\n## Why Code Mode?\n\nResearch from Cloudflare and Anthropic shows Code Mode provides:\n- **81-98% token savings** vs sequential tool call sequences\n- **Explicit control flow** - loops, conditionals, error handling in code\n- **Reusable patterns** - functions and variables persist across iterations\n- **Better debugging** - executable code is easier to trace and verify\n\n## Available Libraries\n\nWhen generating Python code, you have access to:\n```python\nimport math # Mathematical functions (factorial, sqrt, sin, cos, etc.)\nimport json # JSON parsing and serialization\nimport datetime # Date and time operations\nfrom datetime import timedelta\nimport re # Regular expressions for text processing\nimport random # Random number generation\nfrom collections import Counter, defaultdict # Data structures\n```\n\n## Core Pattern\n\n1. **Analyze** - Understand the complete task requirements\n2. **Generate** - Write complete Python code that solves the entire task\n3. **Execute** - Use the `python_code` tool to run the code\n4. **Return** - The code output becomes your response\n\n## Simple Example\n\n**Task**: \"Calculate factorial of 10 and check if it's divisible by 7\"\n\n**Wrong approach** (multiple tool calls - wasteful):\n```\n1. Call calculator: factorial(10)\n2. Get result: 3628800\n3. Call calculator: 3628800 % 7\n4. Get result: 0\n5. Return answer\n(4 LLM round-trips, ~4000 tokens)\n```\n\n**Code Mode approach** (single execution):\n```python\nimport math\nimport json\n\n# Calculate factorial\nresult = math.factorial(10)\n\n# Check divisibility\ndivisible = result % 7 == 0\n\n# Output structured result\noutput = {\n \"factorial_of_10\": result,\n \"divisible_by_7\": divisible,\n \"remainder\": result % 7\n}\nprint(json.dumps(output, indent=2))\n```\n(2 LLM round-trips, ~800 tokens - 80% savings)\n\n## Complex Example with Loop\n\n**Task**: \"Find all prime numbers between 1 and 100, show which are twin primes\"\n\n```python\nimport json\n\ndef is_prime(n):\n \"\"\"Check if a number is prime.\"\"\"\n if n < 2:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\n\n# Find all primes\nprimes = [n for n in range(1, 101) if is_prime(n)]\n\n# Find twin primes (primes that differ by 2)\ntwin_primes = []\nfor i in range(len(primes) - 1):\n if primes[i + 1] - primes[i] == 2:\n twin_primes.append((primes[i], primes[i + 1]))\n\noutput = {\n \"primes\": primes,\n \"count\": len(primes),\n \"sum\": sum(primes),\n \"twin_primes\": twin_primes,\n \"twin_count\": len(twin_primes)\n}\nprint(json.dumps(output, indent=2))\n```\n\n## Data Processing Example\n\n**Task**: \"Analyze this list of numbers: find mean, median, mode, and standard deviation\"\n\n```python\nimport json\nfrom collections import Counter\nimport math\n\n# Input data (would come from user or previous step)\nnumbers = [23, 45, 67, 23, 89, 45, 23, 67, 90, 12, 45, 78]\n\n# Calculate statistics\nn = len(numbers)\nmean = sum(numbers) / n\n\n# Median\nsorted_nums = sorted(numbers)\nif n % 2 == 0:\n median = (sorted_nums[n//2 - 1] + sorted_nums[n//2]) / 2\nelse:\n median = sorted_nums[n//2]\n\n# Mode\ncounter = Counter(numbers)\nmode = counter.most_common(1)[0][0]\n\n# Standard deviation\nvariance = sum((x - mean) ** 2 for x in numbers) / n\nstd_dev = math.sqrt(variance)\n\noutput = {\n \"data\": numbers,\n \"count\": n,\n \"mean\": round(mean, 2),\n \"median\": median,\n \"mode\": mode,\n \"std_deviation\": round(std_dev, 2),\n \"min\": min(numbers),\n \"max\": max(numbers)\n}\nprint(json.dumps(output, indent=2))\n```\n\n## Error Handling in Code\n\nAlways include error handling for robustness:\n\n```python\nimport json\n\ndef safe_divide(a, b):\n \"\"\"Safely divide two numbers.\"\"\"\n try:\n return {\"result\": a / b, \"success\": True}\n except ZeroDivisionError:\n return {\"error\": \"Division by zero\", \"success\": False}\n except Exception as e:\n return {\"error\": str(e), \"success\": False}\n\n# Example usage\nresults = []\ntest_cases = [(10, 2), (15, 3), (7, 0), (100, 4)]\n\nfor a, b in test_cases:\n result = safe_divide(a, b)\n result[\"operation\"] = f\"{a} / {b}\"\n results.append(result)\n\nprint(json.dumps({\"calculations\": results}, indent=2))\n```\n\n## When NOT to Use Code Mode\n\nUse specific tools instead for:\n- **External API calls** - Use `http_request` tool for network requests\n- **Database operations** - Use data-specific tools\n- **File operations** - Use file-specific tools\n- **User interaction** - Respond directly without code\n- **Real-time data** - Use `web_search` or specific data tools\n- **Device control** - Use Android/device-specific tools\n\n## Integration with Multiple Tools\n\nWhen you need both code AND external tools, use this pattern:\n1. Gather data using appropriate tools (http_request, web_search, etc.)\n2. Process the gathered data using Code Mode\n3. Return the combined result\n\nExample flow:\n```\nUser: \"Search for Python release dates and calculate days since each release\"\n\n1. Use web_search tool: \"Python version release dates\"\n2. Use python_code to process:\n - Parse the dates from search results\n - Calculate days since each release\n - Format output nicely\n```\n\n## Output Format\n\nAlways output results as JSON for downstream processing:\n```python\nimport json\n# ... your calculations ...\nprint(json.dumps(output, indent=2))\n```\n\nThis enables:\n- Easy parsing by downstream nodes\n- Structured data for further processing\n- Clear, readable output for users\n",- "isCustomized": false- },- "error-recovery-skill": {- "enabled": true,- "instructions": "# Error Recovery Pattern\n\nYou are an agent that handles errors gracefully through retry strategies, alternative approaches, and graceful degradation.\n\n## Error Classification\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ ERROR CATEGORIES │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ TRANSIENT (Retry) RECOVERABLE (Alternative) │\n│ ───────────────── ──────────────────────── │\n│ • Network timeout • Missing data → try another │\n│ • Rate limit (429) • Format error → parse differ │\n│ • Service busy (503) • Partial failure → use partial │\n│ • Connection reset • Auth expired → re-auth │\n│ │\n│ PERMANENT (Report) CRITICAL (Escalate) │\n│ ────────────────── ─────────────────── │\n│ • Not found (404) • Security violation │\n│ • Permission denied (403) • Data corruption │\n│ • Invalid input (400) • System failure │\n│ • Resource deleted (410) • Unrecoverable state │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n## Retry Strategy\n\nFor transient errors, use exponential backoff:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ EXPONENTIAL BACKOFF │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ Attempt 1 ──▶ FAIL ──▶ Wait 1 second │\n│ │ │\n│ ▼ │\n│ Attempt 2 ──▶ FAIL ──▶ Wait 2 seconds │\n│ │ │\n│ ▼ │\n│ Attempt 3 ──▶ FAIL ──▶ Wait 4 seconds │\n│ │ │\n│ ▼ │\n│ Attempt 4 ──▶ FAIL ──▶ Report failure │\n│ │\n│ Formula: wait_time = 2^(attempt - 1) seconds │\n│ Max attempts: 4 (configurable) │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n### Code Mode Retry Implementation\n\n```python\nimport json\nimport time\n\ndef with_retry(operation, max_attempts=4):\n \"\"\"Execute operation with exponential backoff retry.\"\"\"\n last_error = None\n\n for attempt in range(1, max_attempts + 1):\n try:\n result = operation()\n return {\"success\": True, \"result\": result, \"attempts\": attempt}\n except Exception as e:\n last_error = str(e)\n\n # Check if error is retryable\n if is_permanent_error(e):\n return {\n \"success\": False,\n \"error\": last_error,\n \"error_type\": \"permanent\",\n \"attempts\": attempt\n }\n\n # Wait before retry (exponential backoff)\n if attempt < max_attempts:\n wait_time = 2 ** (attempt - 1)\n time.sleep(wait_time)\n\n return {\n \"success\": False,\n \"error\": last_error,\n \"error_type\": \"transient_exhausted\",\n \"attempts\": max_attempts\n }\n\ndef is_permanent_error(e):\n \"\"\"Check if error is permanent (should not retry).\"\"\"\n error_msg = str(e).lower()\n permanent_indicators = [\n \"not found\", \"404\",\n \"permission denied\", \"403\", \"forbidden\",\n \"invalid\", \"400\", \"bad request\",\n \"unauthorized\", \"401\"\n ]\n return any(indicator in error_msg for indicator in permanent_indicators)\n\n# Usage\nresult = with_retry(lambda: risky_operation())\nprint(json.dumps(result, indent=2))\n```\n\n## Alternative Approach Pattern\n\nWhen the primary approach fails, try alternatives:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ ALTERNATIVE APPROACHES │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ Primary: API call to service A │\n│ │ │\n│ ▼ │\n│ FAILED (service down) │\n│ │ │\n│ ▼ │\n│ Alternative 1: Try service B (backup API) │\n│ │ │\n│ ▼ │\n│ FAILED (rate limited) │\n│ │ │\n│ ▼ │\n│ Alternative 2: Use cached data │\n│ │ │\n│ ▼ │\n│ SUCCESS (stale but available) │\n│ │ │\n│ ▼ │\n│ Return with warning: \"Data may be outdated\" │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n### Self-Delegation for Retry\n\nUse delegation to retry with a different approach:\n\n```json\n{\n \"task\": \"Retry: Get weather data using alternative source\",\n \"context\": \"Attempt: 2/3\nError: Primary weather API timeout\nPrevious approach: OpenWeatherMap API\nNew approach: Try WeatherAPI.com or use cached forecast\nOriginal request: Weather for New York\"\n}\n```\n\n## Graceful Degradation\n\nWhen full success isn't possible, return partial results:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ GRACEFUL DEGRADATION │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ Request: \"Get user profile with posts and followers\" │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │\n│ │ Profile │ │ Posts │ │ Followers │ │\n│ │ SUCCESS │ │ FAILED │ │ SUCCESS │ │\n│ └─────────────┘ └─────────────┘ └─────────────┘ │\n│ │\n│ Response: │\n│ { │\n│ \"profile\": { ... }, // Full data │\n│ \"posts\": null, // Unavailable │\n│ \"posts_error\": \"Service temporarily unavailable\", │\n│ \"followers\": [ ... ], // Full data │\n│ \"partial\": true, // Indicates degraded response │\n│ \"degraded_fields\": [\"posts\"] │\n│ } │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n### Code Mode Graceful Degradation\n\n```python\nimport json\n\ndef fetch_user_data(user_id):\n \"\"\"Fetch user data with graceful degradation.\"\"\"\n result = {\n \"user_id\": user_id,\n \"partial\": False,\n \"errors\": []\n }\n\n # Try to get profile (required)\n try:\n result[\"profile\"] = get_profile(user_id)\n except Exception as e:\n # Profile is required - cannot degrade\n return {\n \"success\": False,\n \"error\": f\"Cannot fetch required profile: {e}\"\n }\n\n # Try to get posts (optional, can degrade)\n try:\n result[\"posts\"] = get_posts(user_id)\n except Exception as e:\n result[\"posts\"] = None\n result[\"errors\"].append(f\"posts: {e}\")\n result[\"partial\"] = True\n\n # Try to get followers (optional, can degrade)\n try:\n result[\"followers\"] = get_followers(user_id)\n except Exception as e:\n result[\"followers\"] = None\n result[\"errors\"].append(f\"followers: {e}\")\n result[\"partial\"] = True\n\n return {\"success\": True, \"data\": result}\n\n# Simulated functions\ndef get_profile(uid): return {\"name\": \"John\", \"email\": \"[email protected]\"}\ndef get_posts(uid): raise Exception(\"Service unavailable\")\ndef get_followers(uid): return [{\"id\": 1, \"name\": \"Jane\"}]\n\noutput = fetch_user_data(\"user_123\")\nprint(json.dumps(output, indent=2))\n```\n\n## Error Recovery in Agentic Loops\n\nWhen an iteration fails in an agentic loop:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ LOOP ERROR RECOVERY │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ Iteration 2: FAILED │\n│ │ │\n│ ▼ │\n│ Classify Error │\n│ │ │\n│ ├──▶ Transient? ──▶ Retry same iteration │\n│ │ │\n│ ├──▶ Recoverable? ──▶ Try alternative approach │\n│ │ │\n│ └──▶ Permanent? ──▶ Skip or report │\n│ │\n│ Continue to Iteration 3 with updated context: │\n│ \"Iteration 2 failed: [reason]. Proceeding with │\n│ partial results from Iteration 1.\" │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n### Delegation with Error Context\n\n```json\n{\n \"task\": \"Continue: Process remaining items (skip failed)\",\n \"context\": \"Iteration: 3/5\nProgress: Processed items 1-5, item 3 failed (invalid format)\nState: Results for items [1,2,4,5] available\nError handling: Skipping item 3, continuing with remaining\nNext: Process items 6-10\"\n}\n```\n\n## Error Reporting Best Practices\n\n### What to Include\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ ERROR REPORT STRUCTURE │\n├─────────────────────────────────────────────────────────────┤\n│ │\n│ 1. WHAT failed │\n│ \"Failed to send WhatsApp message\" │\n│ │\n│ 2. WHY it failed │\n│ \"Recipient phone number not registered on WhatsApp\" │\n│ │\n│ 3. WHAT was tried │\n│ \"Attempted 3 times with exponential backoff\" │\n│ │\n│ 4. WHAT can be done │\n│ \"Try a different contact method (SMS, email) or │\n│ verify the phone number is correct\" │\n│ │\n│ 5. PARTIAL results (if any) │\n│ \"Message was prepared but not delivered\" │\n│ │\n└─────────────────────────────────────────────────────────────┘\n```\n\n### Example Error Response\n\n```json\n{\n \"success\": false,\n \"error\": {\n \"type\": \"delivery_failed\",\n \"message\": \"Failed to send WhatsApp message\",\n \"reason\": \"Recipient not on WhatsApp\",\n \"attempts\": 3,\n \"recovery_attempted\": true,\n \"partial_result\": {\n \"message_prepared\": true,\n \"recipient_validated\": false\n }\n },\n \"suggestions\": [\n \"Verify the phone number format (+1234567890)\",\n \"Try sending via SMS instead\",\n \"Check if recipient has WhatsApp installed\"\n ]\n}\n```\n\n## Anti-Patterns to Avoid\n\n### 1. Silent Failures\n```\n// Never do this\ntry:\n result = risky_operation()\nexcept:\n pass // Error swallowed silently\n\n// Always report\ntry:\n result = risky_operation()\nexcept Exception as e:\n return {\"success\": False, \"error\": str(e)}\n```\n\n### 2. Infinite Retry\n```\n// Never do this\nwhile True:\n try:\n result = operation()\n break\n except:\n continue // Infinite loop\n\n// Always limit attempts\nfor attempt in range(MAX_ATTEMPTS):\n ...\n```\n\n### 3. Retry Permanent Errors\n```\n// Never retry these\n- 404 Not Found\n- 403 Forbidden\n- 401 Unauthorized\n- 400 Bad Request\n\n// Only retry these\n- 429 Too Many Requests\n- 503 Service Unavailable\n- 504 Gateway Timeout\n- Connection errors\n```\n\n### 4. Lose Context on Error\n```\n// Never do this\nexcept Exception:\n return \"An error occurred\"\n\n// Preserve context\nexcept Exception as e:\n return f\"Failed at step {step}: {e}. Progress: {progress}\"\n```\n",- "isCustomized": false- }- },- "label": "Master Skill"- },- "taskManager-1772283382254": {- "toolName": "task_manager",- "toolDescription": "Manage delegated tasks - list active/completed tasks, check task status, mark tasks done",- "operation": "list_tasks",- "task_id": "",- "status_filter": "",- "label": "Task Manager"- },- "coding_agent-1772286449045": {- "provider": "openai",- "model": "gpt-5.2",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant",- "label": "Coding Agent"- },- "web_agent-1772286450006": {- "provider": "openai",- "model": "gpt-5.2",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant",- "label": "Web Control Agent"- },- "social_agent-1772286452768": {- "provider": "openai",- "model": "gpt-5.2",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant",- "label": "Social Media Agent"- },- "productivity_agent-1772286457333": {- "provider": "openai",- "model": "gpt-5.2",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant",- "label": "Productivity Agent"- },- "pythonExecutor-1772286519369": {- "code": "# Python Executor - Transform and process data\n#\n# Available:\n# input_data - dict with connected node outputs\n# math, json - imported modules\n# print() - for debugging\n#\n# Set the \"output\" variable with your result\n\n# Example: Get data from connected node\ndata = input_data.get(\"start\", {}) or input_data\n\n# Process data\nresult = {\n \"message\": \"Hello from Python!\",\n \"input_received\": data,\n \"processed\": True\n}\n\n# Set output (required)\noutput = result",- "label": "Python Executor"- },- "whatsappDb-1772286523527": {- "operation": "chat_history",- "chat_type": "individual",- "phone": "",- "group_id": "",- "group_filter": "all",- "sender_phone": "",- "message_filter": "all",- "limit": 50,- "offset": 0,- "query": "",- "group_id_for_info": "",- "contact_phone": "",- "phones": "",- "channel_jid": "",- "refresh": false,- "channel_count": 10,- "before_server_id": 0,- "channel_name": "",- "channel_description": "",- "label": "WhatsApp DB"- },- "perplexitySearch-1772286538579": {- "toolName": "perplexity_search",- "toolDescription": "Search the web using Perplexity Sonar AI. Returns an AI-generated answer with citations and source URLs.",- "query": "",- "model": "sonar",- "searchRecencyFilter": "",- "returnImages": false,- "returnRelatedQuestions": false,- "label": "Perplexity Search"- },- "gmail-1772286542794": {- "operation": "send",- "account_mode": "owner",- "customer_id": "",- "to": "",- "cc": "",- "bcc": "",- "subject": "",- "body_type": "text",- "body": "",- "query": "",- "max_results": 10,- "include_body": false,- "message_id": "",- "format": "full",- "label": "Gmail"- },- "sheets-1772286546873": {- "operation": "read",- "account_mode": "owner",- "customer_id": "",- "spreadsheet_id": "",- "range": "",- "value_render_option": "FORMATTED_VALUE",- "major_dimension": "ROWS",- "values": "",- "value_input_option": "USER_ENTERED",- "insert_data_option": "INSERT_ROWS",- "label": "Sheets"- },- "masterSkill-1772286623655": {- "skillFolder": "assistant",- "skillsConfig": {- "duckduckgo-search-skill": {- "enabled": true,- "instructions": "# DuckDuckGo Search Skill\n\nThis skill enables free web search via DuckDuckGo. No API key required.\n\nFor premium search providers, see the dedicated skills:\n- **brave-search-skill** - Brave Search API (independent index, privacy-focused)\n- **serper-search-skill** - Serper API (Google-powered, news/images/places)\n- **perplexity-search-skill** - Perplexity Sonar AI (synthesized answers with citations)\n\n## How It Works\n\nThis skill provides instructions and context. To execute web searches, connect the **DuckDuckGo Search** node to the agent's `input-tools` handle.\n\n## web_search Tool\n\nSearch the web using DuckDuckGo and get relevant results.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| query | string | Yes | The search query to look up on the web |\n\n### Node Parameters\n\n| Parameter | Default | Description |\n|-----------|---------|-------------|\n| maxResults | 5 | Number of results to return |\n\n### Examples\n\n**Basic search:**\n```json\n{\n \"query\": \"latest news about artificial intelligence\"\n}\n```\n\n**Factual search:**\n```json\n{\n \"query\": \"population of Tokyo 2024\"\n}\n```\n\n**Current events:**\n```json\n{\n \"query\": \"weather forecast New York today\"\n}\n```\n\n**Technical search:**\n```json\n{\n \"query\": \"how to use Python asyncio gather\"\n}\n```\n\n### Response Format\n\n```json\n{\n \"query\": \"artificial intelligence news\",\n \"results\": [\n {\n \"title\": \"AI Breakthrough in Medical Research\",\n \"snippet\": \"Researchers have developed a new AI model that can predict...\",\n \"url\": \"https://example.com/ai-medical-research\"\n },\n {\n \"title\": \"OpenAI Announces New Model\",\n \"snippet\": \"The company revealed its latest advancement in...\",\n \"url\": \"https://example.com/openai-announcement\"\n }\n ],\n \"provider\": \"duckduckgo\"\n}\n```\n\n## When to Use DuckDuckGo Search\n\nUse DuckDuckGo search when the user asks about:\n\n1. **Current events and news** - Recent happenings, breaking news, current affairs\n2. **Real-time data** - Stock prices, weather, sports scores, exchange rates\n3. **Recent information** - Events, releases, or changes after your knowledge cutoff\n4. **Specific facts** - Population, statistics, dates that may have changed\n5. **Technical documentation** - Latest API docs, library versions, tutorials\n6. **Local information** - Business hours, addresses, phone numbers\n7. **Product information** - Prices, availability, reviews\n\n## When NOT to Use DuckDuckGo Search\n\nAvoid searching when:\n\n1. **General knowledge** - Well-established facts that won't change\n2. **Simple calculations** - Use the calculator tool instead\n3. **Creative tasks** - Writing, brainstorming, analysis\n4. **Personal advice** - Relationship, life decisions\n5. **Subjective opinions** - Preferences, recommendations without factual basis\n\n## Choosing the Right Search Provider\n\n| Need | Recommended Provider | Tool Node |\n|------|---------------------|-----------|\n| Free search, no API key | DuckDuckGo | DuckDuckGo Search |\n| Google-quality results | Serper | Serper Search |\n| News, images, places | Serper | Serper Search |\n| Privacy-focused, independent | Brave | Brave Search |\n| AI-synthesized answers | Perplexity | Perplexity Search |\n| Research with citations | Perplexity | Perplexity Search |\n\n## Search Query Best Practices\n\n### Do:\n- Use specific, focused queries\n- Include relevant keywords\n- Add context like dates, locations, or names\n- Break complex questions into simpler searches\n\n### Don't:\n- Use overly long queries (keep under 10 words when possible)\n- Include unnecessary words like \"please\" or \"can you tell me\"\n- Ask questions as full sentences (use keywords instead)\n\n### Examples of Good vs Bad Queries\n\n| Bad Query | Good Query |\n|-----------|------------|\n| \"Can you please tell me what the weather is like in London today?\" | \"London weather today\" |\n| \"I want to know about the latest iPhone model and its features\" | \"iPhone 16 Pro specifications\" |\n| \"What is happening in the stock market right now?\" | \"stock market news today\" |\n\n## Handling Results\n\n1. **Summarize** the key findings from search results\n2. **Cite sources** when providing specific information\n3. **Indicate uncertainty** if results are conflicting or unclear\n4. **Suggest follow-up searches** if the initial results are insufficient\n5. **Combine multiple searches** for comprehensive answers\n\n## Limitations\n\n- DuckDuckGo uses the `ddgs` library (free, no API key)\n- Results depend on DuckDuckGo's index\n- Some recent events may not be indexed immediately\n- Paywalled content may show limited snippets\n- Results are in English by default\n\n## Setup Requirements\n\n1. Connect this skill to the agent's `input-skill` handle\n2. Connect the **DuckDuckGo Search** node to the agent's `input-tools` handle\n3. No API key required for DuckDuckGo\n",- "isCustomized": false- },- "http-request-skill": {- "enabled": true,- "instructions": "# HTTP Request Tool\n\nMake HTTP requests to external APIs and web services.\n\n## How It Works\n\nThis skill provides instructions for the **HTTP Request** tool node. Connect the **HTTP Request** node to Zeenie's `input-tools` handle to enable API calls.\n\n## http_request Tool\n\nMake an HTTP request to any URL.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| url | string | Yes | Full URL to request (e.g., `https://api.example.com/data`) |\n| method | string | No | HTTP method: `GET`, `POST`, `PUT`, `DELETE`, `PATCH` (default: `GET`) |\n| body | object | No | Request body as JSON object (for POST/PUT/PATCH) |\n| useProxy | boolean | No | Route through proxy (default: `false`). The proxy service handles provider selection, geo-targeting, and session type automatically. |\n\n### Node Parameters\n\nAdditional options can be configured on the node:\n\n| Parameter | Description |\n|-----------|-------------|\n| headers | Custom headers as JSON (e.g., `{\"Authorization\": \"Bearer token\"}`) |\n| base_url | Base URL prepended to the url parameter |\n\n### Response Format\n\n```json\n{\n \"status\": 200,\n \"data\": { \"key\": \"value\" },\n \"url\": \"https://api.example.com/data\",\n \"method\": \"GET\",\n \"proxied\": false\n}\n```\n\n### Examples\n\n**GET request (fetch data):**\n```json\n{\n \"url\": \"https://api.example.com/users/123\",\n \"method\": \"GET\"\n}\n```\n\n**POST request (create resource):**\n```json\n{\n \"url\": \"https://api.example.com/users\",\n \"method\": \"POST\",\n \"body\": {\n \"name\": \"John Doe\",\n \"email\": \"[email protected]\"\n }\n}\n```\n\n**PUT request (update resource):**\n```json\n{\n \"url\": \"https://api.example.com/users/123\",\n \"method\": \"PUT\",\n \"body\": {\n \"name\": \"John Updated\"\n }\n}\n```\n\n**DELETE request:**\n```json\n{\n \"url\": \"https://api.example.com/users/123\",\n \"method\": \"DELETE\"\n}\n```\n\n**PATCH request (partial update):**\n```json\n{\n \"url\": \"https://api.example.com/users/123\",\n \"method\": \"PATCH\",\n \"body\": {\n \"status\": \"active\"\n }\n}\n```\n\n### Real-World Examples\n\n**Get Bitcoin price:**\n```json\n{\n \"url\": \"https://api.coindesk.com/v1/bpi/currentprice.json\",\n \"method\": \"GET\"\n}\n```\n\n**Get weather:**\n```json\n{\n \"url\": \"https://api.openweathermap.org/data/2.5/weather?q=London&appid=YOUR_KEY\",\n \"method\": \"GET\"\n}\n```\n\n**Post to webhook:**\n```json\n{\n \"url\": \"https://hooks.slack.com/services/xxx\",\n \"method\": \"POST\",\n \"body\": {\n \"text\": \"Hello from MachinaOS!\"\n }\n}\n```\n\n**Check website status:**\n```json\n{\n \"url\": \"https://example.com\",\n \"method\": \"GET\"\n}\n```\n\n### Error Responses\n\n**Timeout:**\n```json\n{\n \"error\": \"Request timed out\"\n}\n```\n\n**Connection failed:**\n```json\n{\n \"error\": \"Connection failed: Unable to reach host\"\n}\n```\n\n**HTTP error:**\n```json\n{\n \"status\": 404,\n \"data\": \"Not Found\",\n \"url\": \"https://api.example.com/missing\",\n \"method\": \"GET\"\n}\n```\n\n## HTTP Status Codes\n\n| Status | Meaning | Action |\n|--------|---------|--------|\n| 200-299 | Success | Process the response data |\n| 400 | Bad Request | Check request parameters |\n| 401 | Unauthorized | Check API key/authentication |\n| 403 | Forbidden | Insufficient permissions |\n| 404 | Not Found | Check URL path |\n| 429 | Too Many Requests | Rate limited, wait and retry |\n| 500-599 | Server Error | External service issue |\n\n## Use Cases\n\n| Use Case | Method | Description |\n|----------|--------|-------------|\n| Fetch data | GET | Retrieve resources |\n| Create resource | POST | Add new data |\n| Update resource | PUT/PATCH | Modify existing data |\n| Delete resource | DELETE | Remove data |\n| Health check | GET | Verify service availability |\n| Webhook trigger | POST | Send events to services |\n\n## Proxy Usage\n\nTo route a request through a residential proxy, just set `useProxy: true`. The proxy service automatically selects the best provider, geo-target, and session type from its configuration. A proxy provider must be configured first via the `proxy_config` tool (see proxy-config-skill).\n\n**Proxied request:**\n```json\n{\n \"url\": \"https://example.com/data\",\n \"method\": \"GET\",\n \"useProxy\": true\n}\n```\n\nIf no proxy providers are configured or the proxy lookup fails, the request proceeds directly without a proxy and `\"proxied\": false` appears in the response.\n\n## Guidelines\n\n1. **URLs**: Must be fully qualified with protocol (https://)\n2. **Authentication**: Use node headers for API keys/tokens\n3. **Timeout**: Default 30 seconds\n4. **JSON body**: Automatically serialized for POST/PUT/PATCH\n5. **Response**: JSON responses are automatically parsed\n6. **Proxy**: Set `useProxy: true` to route through proxy -- the proxy service handles all routing details\n\n## Security Notes\n\n1. Never expose API keys in responses to users\n2. Validate URLs before making requests\n3. Avoid internal/private network addresses (localhost, 192.168.x.x)\n4. Respect rate limits of external services\n5. Don't store sensitive data from API responses\n\n## Setup Requirements\n\n1. Connect the **HTTP Request** node to Zeenie's `input-tools` handle\n2. Configure authentication headers on the node if needed\n3. Ensure network access to target APIs\n4. For proxy usage: configure a proxy provider via the proxy-config-skill first\n",- "isCustomized": false- },- "perplexity-search-skill": {- "enabled": true,- "instructions": "# Perplexity Search Skill\n\nSearch the web using Perplexity's Sonar AI models. Unlike traditional search engines that return links, Perplexity provides synthesized AI-generated answers with inline citations and source URLs.\n\n## How It Works\n\nThis skill provides instructions and context. To execute searches, connect the **Perplexity Search** node to the agent's `input-tools` handle.\n\n## perplexity_search Tool\n\nAsk a question and get an AI-synthesized answer with citations.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| query | string | Yes | Question or search query to get AI-powered answer with citations |\n\n### Node Parameters\n\nAdditional options configured on the node:\n\n| Parameter | Default | Description |\n|-----------|---------|-------------|\n| model | sonar | Model: sonar (fast), sonar-pro (deeper research) |\n| searchRecencyFilter | (empty) | Filter results by recency: month, week, day, hour |\n| returnImages | false | Include relevant images in response |\n| returnRelatedQuestions | false | Include follow-up question suggestions |\n\n### Response Format\n\n```json\n{\n \"query\": \"What are the latest developments in quantum computing?\",\n \"answer\": \"Recent developments in quantum computing include several significant breakthroughs. **Google's Willow chip** demonstrated error correction below the threshold needed for reliable quantum computation [1]. **IBM** released its 1,121-qubit Condor processor [2], while **Microsoft** announced a new topological qubit approach [3].\\n\\nKey areas of progress:\\n- Error correction advances\\n- Increased qubit counts\\n- New materials and architectures\\n- Growing commercial applications\",\n \"citations\": [\n \"https://blog.google/technology/research/quantum-computing-willow/\",\n \"https://research.ibm.com/blog/condor-processor\",\n \"https://azure.microsoft.com/en-us/blog/quantum/\"\n ],\n \"results\": [\n {\"url\": \"https://blog.google/technology/research/quantum-computing-willow/\"},\n {\"url\": \"https://research.ibm.com/blog/condor-processor\"},\n {\"url\": \"https://azure.microsoft.com/en-us/blog/quantum/\"}\n ],\n \"model\": \"sonar\",\n \"provider\": \"perplexity\",\n \"images\": [],\n \"related_questions\": [\n \"What is quantum error correction?\",\n \"How many qubits does a useful quantum computer need?\"\n ]\n}\n```\n\n### Examples\n\n**Research question:**\n```json\n{\n \"query\": \"What are the latest developments in quantum computing?\"\n}\n```\n\n**Technical question:**\n```json\n{\n \"query\": \"How does React Server Components work in Next.js 15?\"\n}\n```\n\n**Current events:**\n```json\n{\n \"query\": \"What happened at the latest AI safety summit?\"\n}\n```\n\n**Comparison:**\n```json\n{\n \"query\": \"Compare PostgreSQL vs MySQL for large-scale applications\"\n}\n```\n\n## When to Use Perplexity Search\n\n- **Research questions** - Get synthesized, well-structured answers with citations\n- **Technical explanations** - Detailed answers about how things work\n- **Current events analysis** - AI-summarized coverage of recent events\n- **Comparison queries** - Side-by-side analysis of options\n- **Complex topics** - Multi-faceted questions that benefit from AI synthesis\n- **When you need citations** - Every claim backed by source URLs\n\n## When NOT to Use Perplexity Search\n\n- **Simple factual lookups** - Use Brave or Serper for quick facts\n- **Image search** - Use Serper with searchType \"images\"\n- **Local business search** - Use Serper with searchType \"places\"\n- **High-volume queries** - Perplexity costs more per query ($0.005)\n- **Simple calculations** - Use the calculator tool\n\n## Key Differences from Traditional Search\n\n| Aspect | Traditional Search (Brave/Serper) | Perplexity Sonar |\n|--------|----------------------------------|-----------------|\n| Output | List of links with snippets | AI-written answer with inline citations |\n| Format | title + snippet + URL | Full markdown answer with [1][2] references |\n| Best for | Quick lookups, browsing | Research, explanations, synthesis |\n| Speed | Faster | Slightly slower (AI generation) |\n| Cost | $0.001-0.003/query | $0.005/query |\n\n## Answer Format\n\nThe `answer` field contains rich markdown:\n- **Bold text** for emphasis\n- Numbered citations [1][2] referencing the `citations` array\n- Bullet points and lists for structured information\n- Headers for organized sections\n- Code blocks for technical content\n\n## API Details\n\n- **API**: POST `https://api.perplexity.ai/chat/completions`\n- **Auth**: `Authorization: Bearer` header\n- **Models**: `sonar` (fast, default), `sonar-pro` (deeper research)\n- **Timeout**: 60 seconds (AI generation takes longer than traditional search)\n- **Pricing**: ~$0.005 per request\n\n## Setup Requirements\n\n1. Connect this skill to the agent's `input-skill` handle\n2. Connect the **Perplexity Search** node to the agent's `input-tools` handle\n3. Add your Perplexity API key in Credentials > Search\n",- "isCustomized": false- },- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- }- },- "label": "Master Skill 1"- },- "masterSkill-1772286624787": {- "skillFolder": "productivity_agent",- "skillsConfig": {- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "sheets-skill": {- "enabled": true,- "instructions": "# Google Sheets Skill\n\nRead and write data to Google Sheets spreadsheets.\n\n## Tool: google_sheets\n\nConsolidated Google Sheets tool with `operation` parameter.\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `read` | Read data from a range | spreadsheet_id, range |\n| `write` | Write data to a range | spreadsheet_id, range, values |\n| `append` | Append rows to a table | spreadsheet_id, range, values |\n\n### read - Read spreadsheet data\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"read\"` |\n| spreadsheet_id | string | Yes | Spreadsheet ID from URL |\n| range | string | Yes | A1 notation range (e.g., \"Sheet1!A1:D10\") |\n\n**How to find Spreadsheet ID:**\nFrom URL: `https://docs.google.com/spreadsheets/d/SPREADSHEET_ID/edit`\n\n**Range Notation (A1):**\n- `Sheet1!A1:D10` - Specific range on Sheet1\n- `Sheet1!A:D` - Entire columns A through D\n- `Sheet1!1:10` - Rows 1 through 10\n- `A1:D10` - Default sheet, specific range\n- `Sheet1` - Entire sheet\n\n**Example:**\n```json\n{\n \"operation\": \"read\",\n \"spreadsheet_id\": \"1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms\",\n \"range\": \"Sheet1!A1:E10\"\n}\n```\n\n### write - Write data to a range\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"write\"` |\n| spreadsheet_id | string | Yes | Spreadsheet ID |\n| range | string | Yes | A1 notation range |\n| values | array | Yes | 2D array of values |\n| value_input_option | string | No | `\"USER_ENTERED\"` or `\"RAW\"` (default: USER_ENTERED) |\n\n**Example - Write data:**\n```json\n{\n \"operation\": \"write\",\n \"spreadsheet_id\": \"1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms\",\n \"range\": \"Sheet1!A1:C3\",\n \"values\": [\n [\"Name\", \"Score\", \"Grade\"],\n [\"Alice\", 95, \"A\"],\n [\"Bob\", 87, \"B\"]\n ]\n}\n```\n\n**Example - Write formula:**\n```json\n{\n \"operation\": \"write\",\n \"spreadsheet_id\": \"1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms\",\n \"range\": \"Sheet1!D2\",\n \"values\": [[\"=SUM(B2:C2)\"]],\n \"value_input_option\": \"USER_ENTERED\"\n}\n```\n\n### append - Append rows to a table\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"append\"` |\n| spreadsheet_id | string | Yes | Spreadsheet ID |\n| range | string | Yes | Table range (e.g., \"Sheet1!A:E\") |\n| values | array | Yes | 2D array of rows to append |\n| value_input_option | string | No | `\"USER_ENTERED\"` or `\"RAW\"` (default: USER_ENTERED) |\n| insert_data_option | string | No | `\"INSERT_ROWS\"` or `\"OVERWRITE\"` (default: INSERT_ROWS) |\n\n**Example:**\n```json\n{\n \"operation\": \"append\",\n \"spreadsheet_id\": \"1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms\",\n \"range\": \"Sheet1!A:E\",\n \"values\": [\n [\"Charlie\", \"[email protected]\", \"Sales\", \"2024-02-01\", \"Active\"],\n [\"Diana\", \"[email protected]\", \"HR\", \"2024-02-15\", \"Active\"]\n ]\n}\n```\n\n## Common Formulas\n\n| Formula | Description |\n|---------|-------------|\n| `=SUM(A1:A10)` | Sum of range |\n| `=AVERAGE(B1:B10)` | Average of range |\n| `=COUNT(A:A)` | Count numbers in column |\n| `=COUNTA(A:A)` | Count non-empty cells |\n| `=VLOOKUP(E1,A:C,2,FALSE)` | Vertical lookup |\n| `=IF(A1>90,\"A\",\"B\")` | Conditional logic |\n| `=TODAY()` | Current date |\n| `=NOW()` | Current date and time |\n\n## Common Workflows\n\n1. **Import data**: Write headers, then append data rows\n2. **Update records**: Read to find row, write to specific cells\n3. **Generate reports**: Read data, process, write summary\n4. **Log entries**: Append new rows with timestamps\n\n## Tips\n\n- Always check spreadsheet exists before writing\n- Use `USER_ENTERED` for formulas to work\n- Range must match data dimensions\n- Append is safer than write for adding data\n\n## Setup Requirements\n\n1. Connect Sheets node to AI Agent's `input-tools` handle\n2. Authenticate with Google Workspace in Credentials Modal\n3. Ensure Sheets API scopes are authorized\n4. Spreadsheet must be accessible to authenticated account\n",- "isCustomized": false- },- "gmail-skill": {- "enabled": true,- "instructions": "# Gmail Skill\n\nSend, search, and read emails using Gmail API.\n\n## Tool: google_gmail\n\nConsolidated Gmail tool with `operation` parameter.\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `send` | Send an email | to, subject, body |\n| `search` | Search emails by query | query |\n| `read` | Read email by ID | message_id |\n\n### send - Send an email\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"send\"` |\n| to | string | Yes | Recipient email address |\n| subject | string | Yes | Email subject line |\n| body | string | Yes | Email body (plain text or HTML) |\n| cc | string | No | CC recipients (comma-separated) |\n| bcc | string | No | BCC recipients (comma-separated) |\n| body_type | string | No | `\"text\"` or `\"html\"` (default: text) |\n\n**Example - Send plain text email:**\n```json\n{\n \"operation\": \"send\",\n \"to\": \"[email protected]\",\n \"subject\": \"Meeting Tomorrow\",\n \"body\": \"Hi,\\n\\nJust a reminder about our meeting tomorrow at 2pm.\\n\\nBest regards\"\n}\n```\n\n**Example - Send HTML email:**\n```json\n{\n \"operation\": \"send\",\n \"to\": \"[email protected]\",\n \"subject\": \"Weekly Report\",\n \"body\": \"<h1>Weekly Report</h1><p>Here are the highlights...</p>\",\n \"body_type\": \"html\"\n}\n```\n\n### search - Search emails\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"search\"` |\n| query | string | Yes | Gmail search query |\n| max_results | integer | No | Maximum results (default: 10, max: 100) |\n| include_body | boolean | No | Fetch full message body (default: false) |\n\n**Query Syntax Examples:**\n- `from:[email protected]` - Emails from specific sender\n- `to:[email protected]` - Emails to specific recipient\n- `subject:meeting` - Emails with \"meeting\" in subject\n- `has:attachment` - Emails with attachments\n- `is:unread` - Unread emails\n- `after:2024/01/01` - Emails after date\n- `before:2024/12/31` - Emails before date\n- `label:important` - Emails with label\n- `\"exact phrase\"` - Exact phrase match\n- `from:[email protected] is:unread` - Combine multiple filters\n\n**Example:**\n```json\n{\n \"operation\": \"search\",\n \"query\": \"from:[email protected] has:attachment after:2024/01/01\",\n \"max_results\": 20\n}\n```\n\n### read - Read email content\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"read\"` |\n| message_id | string | Yes | Gmail message ID from search results |\n| format | string | No | `\"full\"`, `\"minimal\"`, `\"raw\"`, `\"metadata\"` (default: full) |\n\n**Example:**\n```json\n{\n \"operation\": \"read\",\n \"message_id\": \"abc123\"\n}\n```\n\n## Common Workflows\n\n1. **Check unread emails**: Search with `is:unread`, then read important ones\n2. **Find emails from someone**: Search with `from:[email protected]`\n3. **Reply to email**: Read the email first, then send with same subject prefixed with \"Re:\"\n4. **Forward email**: Read email, send to new recipient with \"Fwd:\" prefix\n\n## Setup Requirements\n\n1. Connect Gmail node to AI Agent's `input-tools` handle\n2. Authenticate with Google Workspace in Credentials Modal\n3. Ensure Gmail API scopes are authorized\n",- "isCustomized": false- }- },- "label": "Master Skill 2"- },- "masterSkill-1772286639206": {- "skillFolder": "coding_agent",- "skillsConfig": {- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "python-skill": {- "enabled": true,- "instructions": "# Python Code Execution Tool\n\nExecute Python code for calculations, data processing, and automation tasks.\n\n## How It Works\n\nThis skill provides instructions for the **Python Executor** tool node. Connect the **Python Executor** node to Zeenie's `input-tools` handle to enable Python code execution.\n\n## python_code Tool\n\nExecute Python code and return results.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| code | string | Yes | Python code to execute |\n\n### Available Libraries\n\n| Library | Description |\n|---------|-------------|\n| `math` | Mathematical functions (sqrt, pow, sin, cos, etc.) |\n| `json` | JSON encoding/decoding |\n| `datetime` | Date and time manipulation |\n| `timedelta` | Time duration calculations |\n| `re` | Regular expressions |\n| `random` | Random number generation |\n| `Counter` | Count hashable objects |\n| `defaultdict` | Dictionary with default values |\n\n### Built-in Variables\n\n| Variable | Description |\n|----------|-------------|\n| `input_data` | Data from connected workflow nodes (dict) |\n| `output` | Set this to return a result |\n\n### Output Methods\n\n1. **Set `output` variable**: Returns structured data to the workflow\n2. **Use `print()`**: Captured as console output\n\n### Examples\n\n**Basic calculation:**\n```json\n{\n \"code\": \"result = 25 * 4 + 10\\nprint(f'Result: {result}')\\noutput = result\"\n}\n```\n\n**Calculate tip:**\n```json\n{\n \"code\": \"bill = 85.50\\ntip_percent = 15\\ntip = bill * (tip_percent / 100)\\ntotal = bill + tip\\nprint(f'Tip: ${tip:.2f}')\\nprint(f'Total: ${total:.2f}')\\noutput = {'tip': tip, 'total': total}\"\n}\n```\n\n**Generate random numbers:**\n```json\n{\n \"code\": \"import random\\nnumbers = [random.randint(1, 100) for _ in range(5)]\\nprint(f'Random numbers: {numbers}')\\noutput = numbers\"\n}\n```\n\n**Date calculations:**\n```json\n{\n \"code\": \"from datetime import datetime, timedelta\\ntoday = datetime.now()\\nfuture = today + timedelta(days=30)\\nresult = future.strftime('%Y-%m-%d')\\nprint(f'30 days from now: {result}')\\noutput = result\"\n}\n```\n\n**Process data:**\n```json\n{\n \"code\": \"data = input_data.get('numbers', [1, 2, 3, 4, 5])\\ntotal = sum(data)\\naverage = total / len(data)\\nprint(f'Total: {total}, Average: {average}')\\noutput = {'total': total, 'average': average}\"\n}\n```\n\n**Parse JSON:**\n```json\n{\n \"code\": \"import json\\njson_str = '{\\\"name\\\": \\\"John\\\", \\\"age\\\": 30}'\\ndata = json.loads(json_str)\\nprint(f'Name: {data[\\\"name\\\"]}')\\noutput = data\"\n}\n```\n\n**Count items:**\n```json\n{\n \"code\": \"from collections import Counter\\nitems = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']\\ncounts = dict(Counter(items))\\nprint(f'Counts: {counts}')\\noutput = counts\"\n}\n```\n\n**Text processing:**\n```json\n{\n \"code\": \"import re\\ntext = 'Contact: [email protected] or [email protected]'\\nemails = re.findall(r'\\\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\\.[A-Z|a-z]{2,}\\\\b', text)\\nprint(f'Found emails: {emails}')\\noutput = emails\"\n}\n```\n\n### Response Format\n\n**Success:**\n```json\n{\n \"success\": true,\n \"result\": {\"tip\": 12.825, \"total\": 98.325},\n \"output\": \"Tip: $12.83\\nTotal: $98.33\"\n}\n```\n\n**Error:**\n```json\n{\n \"error\": \"name 'undefined_var' is not defined\"\n}\n```\n\n## Use Cases\n\n| Use Case | Approach |\n|----------|----------|\n| Math calculations | Use `math` library functions |\n| Date/time operations | Use `datetime` and `timedelta` |\n| Data analysis | Use list comprehensions, sum, len |\n| Random generation | Use `random` library |\n| Text parsing | Use `re` regular expressions |\n| JSON manipulation | Use `json.loads()` and `json.dumps()` |\n| Counting | Use `Counter` from collections |\n\n## Guidelines\n\n1. **Always set `output`**: This returns data to the workflow\n2. **Use `print()` for debugging**: Output is captured and returned\n3. **Keep code focused**: One task per execution\n4. **Handle errors**: Use try/except for robust code\n5. **No network access**: Use http-skill for web requests\n6. **No file system access**: Restricted to safe operations\n7. **Timeout**: Default 30 seconds max execution time\n\n## Security Restrictions\n\n- No network/socket operations\n- No file system access outside designated areas\n- No subprocess/shell commands\n- Limited execution time (30 seconds)\n- Sandboxed environment\n\n## Setup Requirements\n\n1. Connect the **Python Executor** node to Zeenie's `input-tools` handle\n2. Python must be installed on the server\n",- "isCustomized": false- }- },- "label": "Master Skill 3"- },- "masterSkill-1772286641708": {- "skillFolder": "social_agent",- "skillsConfig": {- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "whatsapp-db-skill": {- "enabled": true,- "instructions": "# WhatsApp Database Tool\n\nQuery WhatsApp database for contacts, groups, channels (newsletters), and message history.\n\n## How It Works\n\nThis skill provides instructions for the **WhatsApp DB** tool node. Connect the **WhatsApp DB** node to Zeenie's `input-tools` handle to enable database queries.\n\n## whatsapp_db Tool\n\nQuery contacts, groups, channels, and chat history.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Operation type (see below) |\n| chat_type | string | For chat_history | `\"individual\"` or `\"group\"` |\n| phone | string | Varies | Phone number (for chat_history individual, get_contact_info) |\n| group_id | string | Varies | Group JID (for chat_history group, get_group_info) |\n| query | string | No | Search query (for search_groups, list_contacts) |\n| limit | int | No | Max results (varies by operation) |\n| offset | int | No | Pagination offset (for chat_history) |\n| message_filter | string | No | `\"all\"` or `\"text_only\"` (for chat_history) |\n| group_filter | string | No | `\"all\"` or `\"contact\"` (for group chat_history) |\n| sender_phone | string | No | Filter by sender (when group_filter=\"contact\") |\n| phones | string | For check_contacts | Comma-separated phone numbers |\n| participant_limit | int | No | Max participants (for get_group_info, 1-100) |\n| channel_jid | string | For channel ops | Newsletter JID (e.g., `120363198765432101@newsletter`) |\n| refresh | boolean | No | Force refresh from server (for list_channels, get_channel_info) |\n| channel_count | int | No | Number of items to fetch (for channel_messages, channel_stats) |\n| before_server_id | int | No | Pagination cursor (for channel_messages) |\n| channel_name | string | For channel_create | Name of the new channel |\n| channel_description | string | No | Description (for channel_create) |\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `list_contacts` | List contacts with saved names | query (optional), limit |\n| `get_contact_info` | Get full contact details | phone |\n| `search_groups` | Search groups by name | query, limit |\n| `get_group_info` | Get group details with participants | group_id |\n| `chat_history` | Retrieve message history | chat_type, phone/group_id |\n| `check_contacts` | Check WhatsApp registration | phones |\n| `list_channels` | List subscribed newsletter channels | refresh (optional), limit |\n| `get_channel_info` | Get channel details | channel_jid |\n| `channel_messages` | Get channel message history | channel_jid, channel_count |\n| `channel_stats` | Get channel subscriber/view stats | channel_jid |\n| `channel_follow` | Follow/subscribe to a channel | channel_jid |\n| `channel_unfollow` | Unfollow/unsubscribe from a channel | channel_jid |\n| `channel_create` | Create a new newsletter channel | channel_name |\n\n### Limits\n\n| Operation | Default | Max |\n|-----------|---------|-----|\n| chat_history | 50 | 500 |\n| search_groups | 20 | 50 |\n| list_contacts | 50 | 100 |\n| get_group_info participants | 50 | 100 |\n| list_channels | 20 | 50 |\n| channel_messages | 20 | 100 |\n| channel_stats | 10 | 100 |\n\n**Important:** Always use small limits and specific queries to avoid context overflow.\n\n## Operation Examples\n\n### list_contacts\n\nFind contacts by name.\n\n```json\n{\n \"operation\": \"list_contacts\",\n \"query\": \"mom\",\n \"limit\": 10\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"list_contacts\",\n \"contacts\": [\n {\"phone\": \"919876543210\", \"name\": \"Mom\", \"jid\": \"[email protected]\"}\n ],\n \"total\": 1\n}\n```\n\n### get_contact_info\n\nGet full contact details for sending/replying.\n\n```json\n{\n \"operation\": \"get_contact_info\",\n \"phone\": \"919876543210\"\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"get_contact_info\",\n \"phone\": \"919876543210\",\n \"name\": \"Mom\",\n \"jid\": \"[email protected]\",\n \"profile_picture\": \"https://...\"\n}\n```\n\n### search_groups\n\nSearch groups by name.\n\n```json\n{\n \"operation\": \"search_groups\",\n \"query\": \"family\",\n \"limit\": 10\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"search_groups\",\n \"groups\": [\n {\"group_id\": \"[email protected]\", \"name\": \"Family Group\", \"participant_count\": 5}\n ],\n \"total\": 1\n}\n```\n\n### get_group_info\n\nGet group details with participant list.\n\n```json\n{\n \"operation\": \"get_group_info\",\n \"group_id\": \"[email protected]\",\n \"participant_limit\": 20\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"get_group_info\",\n \"name\": \"Family Group\",\n \"jid\": \"[email protected]\",\n \"participants\": [\n {\"phone\": \"919876543210\", \"name\": \"Mom\", \"is_admin\": true},\n {\"phone\": \"919876543211\", \"name\": \"Dad\", \"is_admin\": false}\n ],\n \"total_participants\": 5\n}\n```\n\n### chat_history (Individual)\n\nGet messages from an individual chat.\n\n```json\n{\n \"operation\": \"chat_history\",\n \"chat_type\": \"individual\",\n \"phone\": \"919876543210\",\n \"limit\": 20\n}\n```\n\n### chat_history (Group)\n\nGet messages from a group chat.\n\n```json\n{\n \"operation\": \"chat_history\",\n \"chat_type\": \"group\",\n \"group_id\": \"[email protected]\",\n \"message_filter\": \"text_only\",\n \"limit\": 50\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"chat_history\",\n \"messages\": [\n {\n \"index\": 1,\n \"message_id\": \"ABC123\",\n \"sender\": \"[email protected]\",\n \"sender_name\": \"Mom\",\n \"text\": \"Hello!\",\n \"timestamp\": \"2025-01-30T12:00:00\",\n \"is_from_me\": false\n }\n ],\n \"total\": 50,\n \"has_more\": true\n}\n```\n\n### check_contacts\n\nCheck if phone numbers have WhatsApp.\n\n```json\n{\n \"operation\": \"check_contacts\",\n \"phones\": \"1234567890,0987654321\"\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"check_contacts\",\n \"results\": [\n {\"phone\": \"1234567890\", \"registered\": true, \"jid\": \"[email protected]\"},\n {\"phone\": \"0987654321\", \"registered\": false}\n ]\n}\n```\n\n### list_channels\n\nList subscribed newsletter channels.\n\n```json\n{\n \"operation\": \"list_channels\",\n \"limit\": 10\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"list_channels\",\n \"channels\": [\n {\"jid\": \"120363198765432101@newsletter\", \"name\": \"Tech Updates\", \"subscriber_count\": 5000}\n ],\n \"total\": 3\n}\n```\n\n### get_channel_info\n\nGet channel details.\n\n```json\n{\n \"operation\": \"get_channel_info\",\n \"channel_jid\": \"120363198765432101@newsletter\"\n}\n```\n\n### channel_messages\n\nGet channel message history.\n\n```json\n{\n \"operation\": \"channel_messages\",\n \"channel_jid\": \"120363198765432101@newsletter\",\n \"channel_count\": 10\n}\n```\n\n### channel_follow\n\nFollow/subscribe to a channel.\n\n```json\n{\n \"operation\": \"channel_follow\",\n \"channel_jid\": \"120363198765432101@newsletter\"\n}\n```\n\n### channel_create\n\nCreate a new newsletter channel.\n\n```json\n{\n \"operation\": \"channel_create\",\n \"channel_name\": \"My Channel\",\n \"channel_description\": \"A channel about interesting topics\"\n}\n```\n\n## Common Workflows\n\n### Find and message someone by name\n\n1. Use `list_contacts` with query to find the person\n2. Get their phone number from the result\n3. Use `whatsapp_send` tool with the phone number\n\n### Get recent messages from a contact\n\n1. Use `chat_history` with chat_type=\"individual\"\n2. Set appropriate limit for desired history depth\n\n### Find and message a group\n\n1. Use `search_groups` to find the group by name\n2. Get the group_id from the result\n3. Use `whatsapp_send` tool with recipient_type=\"group\"\n\n### See who's in a group\n\n1. Use `get_group_info` with the group_id\n2. Set participant_limit to control output size\n\n## Guidelines\n\n1. **Phone numbers**: Always use without + prefix, just digits\n2. **Group IDs**: JID format ending in `@g.us`\n3. **Limits**: Use small limits to avoid context overflow\n4. **Queries**: Be specific to narrow results\n5. **Pagination**: Use offset to page through chat_history\n\n## Error Responses\n\n```json\n{\n \"error\": \"Phone number is required for chat_type='individual'\"\n}\n```\n\n```json\n{\n \"error\": \"group_id is required for get_group_info\"\n}\n```\n\n## Setup Requirements\n\n1. Connect the **WhatsApp DB** node to Zeenie's `input-tools` handle\n2. Ensure WhatsApp is connected (green status indicator in Credentials)\n",- "isCustomized": false- }- },- "label": "Master Skill 4"- },- "simpleMemory-1772286654076": {- "label": "Simple Memory 1"- },- "simpleMemory-1772286662040": {- "label": "Simple Memory 2"- },- "simpleMemory-1772286667244": {- "label": "Simple Memory 3"- },- "simpleMemory-1772286673234": {- "label": "Simple Memory 4"- },- "simpleMemory-1772437660092": {- "label": "Simple Memory 5"- },- "masterSkill-1772437683119": {- "label": "Master Skill 5"- },- "telegramReceive-1772718416883": {- "contentTypeFilter": "text",- "senderFilter": "self",- "chat_id": "",- "from_user": "",- "keywords": "",- "ignoreBots": true,- "label": "Telegram Receive"- },- "telegramSend-1772781417360": {- "recipient_type": "self",- "chat_id": "",- "message_type": "text",- "text": "{{aiemployee.response}}",- "media_url": "",- "caption": "",- "latitude": 0,- "longitude": 0,- "phone_number": "",- "first_name": "",- "last_name": "",- "parse_mode": "Auto",- "silent": false,- "reply_to_message_id": 0,- "label": "Telegram Send"- }- }-}\ No newline at end of filediff --git a/workflows/zeenie-assistant.json b/workflows/zeenie-assistant.jsondeleted file mode 100644index 8f4760e0..00000000--- a/workflows/zeenie-assistant.json+++ /dev/null@@ -1,1871 +0,0 @@-{- "id": "zeenie-assistant",- "name": "Zeenie Assistant",- "nodes": [- {- "id": "chatTrigger-1769755237666",- "type": "chatTrigger",- "position": {- "x": 1540,- "y": 60- },- "data": {- "label": "Chat Trigger"- },- "width": 67,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1540,- "y": 60- },- "dragging": false- },- {- "id": "duckduckgoSearch-1769755286327",- "type": "duckduckgoSearch",- "position": {- "x": 2320,- "y": 720- },- "data": {- "label": "DuckDuckGo"- },- "width": 71,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2320,- "y": 720- },- "dragging": false- },- {- "id": "httpRequest-1769755308753",- "type": "httpRequest",- "position": {- "x": 2020,- "y": 720- },- "data": {- "label": "HTTP Request"- },- "width": 76,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2020,- "y": 720- },- "dragging": false- },- {- "id": "pythonExecutor-1769889650412",- "type": "pythonExecutor",- "position": {- "x": 2560,- "y": 720- },- "data": {- "label": "Python Executor"- },- "width": 89,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2560,- "y": 720- },- "dragging": false- },- {- "id": "javascriptExecutor-1769889652348",- "type": "javascriptExecutor",- "position": {- "x": 2680,- "y": 720- },- "data": {- "label": "JavaScript Executor"- },- "width": 105,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2680,- "y": 720- },- "dragging": false- },- {- "id": "chatAgent-1770060581808",- "type": "chatAgent",- "position": {- "x": 2360,- "y": -120- },- "data": {- "label": "Zeenie"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": 2360,- "y": -120- },- "dragging": false- },- {- "id": "gmaps_locations-1770070846926",- "type": "gmaps_locations",- "position": {- "x": 3680,- "y": 720- },- "data": {- "label": "GMaps Locations"- },- "width": 93,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 3680,- "y": 720- },- "dragging": false- },- {- "id": "gmaps_nearby_places-1770070848430",- "type": "gmaps_nearby_places",- "position": {- "x": 3540,- "y": 720- },- "data": {- "label": "GMaps Nearby Places"- },- "width": 118,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 3540,- "y": 720- },- "dragging": false- },- {- "id": "coding_agent-1770070861999",- "type": "coding_agent",- "position": {- "x": 2520,- "y": 380- },- "data": {- "label": "Coding Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": 2520,- "y": 380- },- "dragging": false- },- {- "id": "web_agent-1770070863433",- "type": "web_agent",- "position": {- "x": 2040,- "y": 380- },- "data": {- "label": "Web Control Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": 2040,- "y": 380- },- "dragging": false- },- {- "id": "whatsappDb-1770080085316",- "type": "whatsappDb",- "position": {- "x": 3260,- "y": 720- },- "data": {- "label": "WhatsApp DB"- },- "width": 76,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 3260,- "y": 720- },- "dragging": false- },- {- "id": "masterSkill-1770080471262",- "type": "masterSkill",- "position": {- "x": 1220,- "y": 720- },- "data": {- "label": "Master Skill 1"- },- "width": 71,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1220,- "y": 720- },- "dragging": false- },- {- "id": "masterSkill-1770193690331",- "type": "masterSkill",- "position": {- "x": 2340,- "y": 140- },- "data": {- "label": "Master Skill 2"- },- "width": 73,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2340,- "y": 140- },- "dragging": false- },- {- "id": "masterSkill-1770193844078",- "type": "masterSkill",- "position": {- "x": 1920,- "y": 720- },- "data": {- "label": "Master Skill 3"- },- "width": 73,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1920,- "y": 720- },- "dragging": false- },- {- "id": "masterSkill-1770193849164",- "type": "masterSkill",- "position": {- "x": 2460,- "y": 720- },- "data": {- "label": "Master Skill 4"- },- "width": 73,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2460,- "y": 720- },- "dragging": false- },- {- "id": "console-1770195247780",- "type": "console",- "position": {- "x": 3080,- "y": 100- },- "data": {- "label": "Console 1"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 3080,- "y": 100- },- "dragging": false- },- {- "id": "social_agent-1770213991252",- "type": "social_agent",- "position": {- "x": 3020,- "y": 380- },- "data": {- "label": "Social Media Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": 3020,- "y": 380- },- "dragging": false- },- {- "id": "masterSkill-1770214062703",- "type": "masterSkill",- "position": {- "x": 2980,- "y": 720- },- "data": {- "label": "Master Skill 5"- },- "width": 73,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2980,- "y": 720- },- "dragging": false- },- {- "id": "travel_agent-1770223640970",- "type": "travel_agent",- "position": {- "x": 3440,- "y": 380- },- "data": {- "label": "Travel Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": 3440,- "y": 380- },- "dragging": false- },- {- "id": "masterSkill-1770223871841",- "type": "masterSkill",- "position": {- "x": 3420,- "y": 720- },- "data": {- "label": "Master Skill 6"- },- "width": 73,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 3420,- "y": 720- },- "dragging": false- },- {- "id": "taskTrigger-1770790175153",- "type": "taskTrigger",- "position": {- "x": 1400,- "y": 160- },- "data": {- "label": "Task Completed"- },- "width": 86,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1400,- "y": 160- },- "dragging": false- },- {- "id": "taskManager-1770801430177",- "type": "taskManager",- "position": {- "x": 2700,- "y": 140- },- "data": {- "label": "Task Manager"- },- "width": 75,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2700,- "y": 140- },- "dragging": true- },- {- "id": "simpleMemory-1770973684811",- "type": "simpleMemory",- "position": {- "x": 2180,- "y": 140- },- "data": {- "label": "Simple Memory"- },- "width": 87,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2180,- "y": 140- },- "dragging": false- },- {- "id": "simpleMemory-1770973735815",- "type": "simpleMemory",- "position": {- "x": 1920,- "y": 540- },- "data": {- "label": "Simple Memory 2"- },- "width": 97,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1920,- "y": 540- },- "dragging": false- },- {- "id": "simpleMemory-1770973759469",- "type": "simpleMemory",- "position": {- "x": 2400,- "y": 540- },- "data": {- "label": "Simple Memory 3"- },- "width": 97,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2400,- "y": 540- },- "dragging": false- },- {- "id": "simpleMemory-1770973783506",- "type": "simpleMemory",- "position": {- "x": 2900,- "y": 540- },- "data": {- "label": "Simple Memory 5"- },- "width": 97,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2900,- "y": 540- },- "dragging": true- },- {- "id": "simpleMemory-1770973798020",- "type": "simpleMemory",- "position": {- "x": 3340,- "y": 540- },- "data": {- "label": "Simple Memory 6"- },- "width": 97,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 3340,- "y": 540- },- "dragging": false- },- {- "id": "productivity_agent-1771834433838",- "type": "productivity_agent",- "position": {- "x": 1480,- "y": 380- },- "data": {- "label": "Productivity Agent"- },- "width": 300,- "height": 200,- "selected": false,- "positionAbsolute": {- "x": 1480,- "y": 380- },- "dragging": false- },- {- "id": "twitterSearch-1771834599628",- "type": "twitterSearch",- "position": {- "x": 3080,- "y": 720- },- "data": {- "label": "Twitter Search"- },- "width": 77,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 3080,- "y": 720- },- "dragging": false- },- {- "id": "twitterUser-1771834600973",- "type": "twitterUser",- "position": {- "x": 3180,- "y": 720- },- "data": {- "label": "Twitter User"- },- "width": 65,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 3180,- "y": 720- },- "dragging": false- },- {- "id": "simpleMemory-1771834793747",- "type": "simpleMemory",- "position": {- "x": 1340,- "y": 540- },- "data": {- "label": "Simple Memory 1"- },- "width": 95,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1340,- "y": 540- },- "dragging": true- },- {- "id": "gmail-1772074604463",- "type": "googleGmail",- "position": {- "x": 1820,- "y": 720- },- "data": {- "label": "Gmail"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1820,- "y": 720- },- "dragging": false- },- {- "id": "calendar-1772074605773",- "type": "googleCalendar",- "position": {- "x": 1620,- "y": 720- },- "data": {- "label": "Calendar"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1620,- "y": 720- },- "dragging": false- },- {- "id": "drive-1772074607205",- "type": "googleDrive",- "position": {- "x": 1420,- "y": 720- },- "data": {- "label": "Drive"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1420,- "y": 720- },- "dragging": false- },- {- "id": "sheets-1772074608160",- "type": "googleSheets",- "position": {- "x": 1720,- "y": 720- },- "data": {- "label": "Sheets"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1720,- "y": 720- },- "dragging": false- },- {- "id": "tasks-1772074609131",- "type": "googleTasks",- "position": {- "x": 1520,- "y": 720- },- "data": {- "label": "Tasks"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1520,- "y": 720- },- "dragging": false- },- {- "id": "contacts-1772074610122",- "type": "googleContacts",- "position": {- "x": 1320,- "y": 720- },- "data": {- "label": "Contacts"- },- "width": 60,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1320,- "y": 720- },- "dragging": false- },- {- "id": "perplexitySearch-1772075707557",- "type": "perplexitySearch",- "position": {- "x": 2200,- "y": 720- },- "data": {- "label": "Perplexity Search"- },- "width": 93,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2200,- "y": 720- },- "dragging": false- },- {- "id": "braveSearch-1772075714278",- "type": "braveSearch",- "position": {- "x": 2120,- "y": 720- },- "data": {- "label": "Brave Search"- },- "width": 70,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2120,- "y": 720- },- "dragging": false- },- {- "id": "typescriptExecutor-1772075756858",- "type": "typescriptExecutor",- "position": {- "x": 2800,- "y": 720- },- "data": {- "label": "TypeScript Executor"- },- "width": 107,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 2800,- "y": 720- },- "dragging": false- },- {- "id": "telegramReceive-1772725517789",- "type": "telegramReceive",- "position": {- "x": 1620,- "y": -80- },- "data": {- "label": "Telegram Receive"- },- "width": 94,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 1620,- "y": -80- },- "dragging": false- },- {- "id": "telegramSend-1772781380014",- "type": "telegramSend",- "position": {- "x": 3060,- "y": -20- },- "data": {- "label": "Telegram Send"- },- "width": 80,- "height": 82,- "selected": false,- "positionAbsolute": {- "x": 3060,- "y": -20- },- "dragging": false- }- ],- "edges": [- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1770193690331",- "sourceHandle": "output-main",- "target": "chatAgent-1770060581808",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1770193690331output-main-chatAgent-1770060581808input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "httpRequest-1769755308753",- "sourceHandle": "output-tool",- "target": "web_agent-1770070863433",- "targetHandle": "input-tools",- "id": "reactflow__edge-httpRequest-1769755308753output-tool-web_agent-1770070863433input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "duckduckgoSearch-1769755286327",- "sourceHandle": "output-tool",- "target": "web_agent-1770070863433",- "targetHandle": "input-tools",- "id": "reactflow__edge-duckduckgoSearch-1769755286327output-tool-web_agent-1770070863433input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "pythonExecutor-1769889650412",- "sourceHandle": "output-tool",- "target": "coding_agent-1770070861999",- "targetHandle": "input-tools",- "id": "reactflow__edge-pythonExecutor-1769889650412output-tool-coding_agent-1770070861999input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "javascriptExecutor-1769889652348",- "sourceHandle": "output-tool",- "target": "coding_agent-1770070861999",- "targetHandle": "input-tools",- "id": "reactflow__edge-javascriptExecutor-1769889652348output-tool-coding_agent-1770070861999input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1770193844078",- "sourceHandle": "output-main",- "target": "web_agent-1770070863433",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1770193844078output-main-web_agent-1770070863433input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1770193849164",- "sourceHandle": "output-main",- "target": "coding_agent-1770070861999",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1770193849164output-main-coding_agent-1770070861999input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "coding_agent-1770070861999",- "sourceHandle": "output-top",- "target": "chatAgent-1770060581808",- "targetHandle": "input-tools",- "id": "reactflow__edge-coding_agent-1770070861999output-top-chatAgent-1770060581808input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "chatAgent-1770060581808",- "sourceHandle": "output-main",- "target": "console-1770195247780",- "targetHandle": "input-main",- "id": "reactflow__edge-chatAgent-1770060581808output-main-console-1770195247780input-main",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "social_agent-1770213991252",- "sourceHandle": "output-top",- "target": "chatAgent-1770060581808",- "targetHandle": "input-tools",- "id": "reactflow__edge-social_agent-1770213991252output-top-chatAgent-1770060581808input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "whatsappDb-1770080085316",- "sourceHandle": "output-tool",- "target": "social_agent-1770213991252",- "targetHandle": "input-tools",- "id": "reactflow__edge-whatsappDb-1770080085316output-tool-social_agent-1770213991252input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1770214062703",- "sourceHandle": "output-main",- "target": "social_agent-1770213991252",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1770214062703output-main-social_agent-1770213991252input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "travel_agent-1770223640970",- "sourceHandle": "output-top",- "target": "chatAgent-1770060581808",- "targetHandle": "input-tools",- "id": "reactflow__edge-travel_agent-1770223640970output-top-chatAgent-1770060581808input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "gmaps_locations-1770070846926",- "sourceHandle": "output-tool",- "target": "travel_agent-1770223640970",- "targetHandle": "input-tools",- "id": "reactflow__edge-gmaps_locations-1770070846926output-tool-travel_agent-1770223640970input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "gmaps_nearby_places-1770070848430",- "sourceHandle": "output-tool",- "target": "travel_agent-1770223640970",- "targetHandle": "input-tools",- "id": "reactflow__edge-gmaps_nearby_places-1770070848430output-tool-travel_agent-1770223640970input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1770223871841",- "sourceHandle": "output-main",- "target": "travel_agent-1770223640970",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1770223871841output-main-travel_agent-1770223640970input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "chatTrigger-1769755237666",- "sourceHandle": "output-main",- "target": "chatAgent-1770060581808",- "targetHandle": "input-main",- "id": "reactflow__edge-chatTrigger-1769755237666output-main-chatAgent-1770060581808input-main",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "taskTrigger-1770790175153",- "sourceHandle": "output-main",- "target": "chatAgent-1770060581808",- "targetHandle": "input-task",- "id": "reactflow__edge-taskTrigger-1770790175153output-main-chatAgent-1770060581808input-task",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "taskManager-1770801430177",- "sourceHandle": "output-tool",- "target": "chatAgent-1770060581808",- "targetHandle": "input-tools",- "id": "reactflow__edge-taskManager-1770801430177output-tool-chatAgent-1770060581808input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1770973684811",- "sourceHandle": "output-memory",- "target": "chatAgent-1770060581808",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1770973684811output-memory-chatAgent-1770060581808input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1770973735815",- "sourceHandle": "output-memory",- "target": "web_agent-1770070863433",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1770973735815output-memory-web_agent-1770070863433input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1770973759469",- "sourceHandle": "output-memory",- "target": "coding_agent-1770070861999",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1770973759469output-memory-coding_agent-1770070861999input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1770973783506",- "sourceHandle": "output-memory",- "target": "social_agent-1770213991252",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1770973783506output-memory-social_agent-1770213991252input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1770973798020",- "sourceHandle": "output-memory",- "target": "travel_agent-1770223640970",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1770973798020output-memory-travel_agent-1770223640970input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "web_agent-1770070863433",- "sourceHandle": "output-top",- "target": "chatAgent-1770060581808",- "targetHandle": "input-tools",- "id": "reactflow__edge-web_agent-1770070863433output-top-chatAgent-1770060581808input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "productivity_agent-1771834433838",- "sourceHandle": "output-top",- "target": "chatAgent-1770060581808",- "targetHandle": "input-tools",- "id": "reactflow__edge-productivity_agent-1771834433838output-top-chatAgent-1770060581808input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "masterSkill-1770080471262",- "sourceHandle": "output-main",- "target": "productivity_agent-1771834433838",- "targetHandle": "input-skill",- "id": "reactflow__edge-masterSkill-1770080471262output-main-productivity_agent-1771834433838input-skill",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "twitterSearch-1771834599628",- "sourceHandle": "output-tool",- "target": "social_agent-1770213991252",- "targetHandle": "input-tools",- "id": "reactflow__edge-twitterSearch-1771834599628output-tool-social_agent-1770213991252input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "twitterUser-1771834600973",- "sourceHandle": "output-tool",- "target": "social_agent-1770213991252",- "targetHandle": "input-tools",- "id": "reactflow__edge-twitterUser-1771834600973output-tool-social_agent-1770213991252input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "simpleMemory-1771834793747",- "sourceHandle": "output-memory",- "target": "productivity_agent-1771834433838",- "targetHandle": "input-memory",- "id": "reactflow__edge-simpleMemory-1771834793747output-memory-productivity_agent-1771834433838input-memory",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "contacts-1772074610122",- "sourceHandle": "output-tool",- "target": "productivity_agent-1771834433838",- "targetHandle": "input-tools",- "id": "reactflow__edge-contacts-1772074610122output-tool-productivity_agent-1771834433838input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "drive-1772074607205",- "sourceHandle": "output-tool",- "target": "productivity_agent-1771834433838",- "targetHandle": "input-tools",- "id": "reactflow__edge-drive-1772074607205output-tool-productivity_agent-1771834433838input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "tasks-1772074609131",- "sourceHandle": "output-tool",- "target": "productivity_agent-1771834433838",- "targetHandle": "input-tools",- "id": "reactflow__edge-tasks-1772074609131output-tool-productivity_agent-1771834433838input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "calendar-1772074605773",- "sourceHandle": "output-tool",- "target": "productivity_agent-1771834433838",- "targetHandle": "input-tools",- "id": "reactflow__edge-calendar-1772074605773output-tool-productivity_agent-1771834433838input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "sheets-1772074608160",- "sourceHandle": "output-tool",- "target": "productivity_agent-1771834433838",- "targetHandle": "input-tools",- "id": "reactflow__edge-sheets-1772074608160output-tool-productivity_agent-1771834433838input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "gmail-1772074604463",- "sourceHandle": "output-tool",- "target": "productivity_agent-1771834433838",- "targetHandle": "input-tools",- "id": "reactflow__edge-gmail-1772074604463output-tool-productivity_agent-1771834433838input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "braveSearch-1772075714278",- "sourceHandle": "output-tool",- "target": "web_agent-1770070863433",- "targetHandle": "input-tools",- "id": "reactflow__edge-braveSearch-1772075714278output-tool-web_agent-1770070863433input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "perplexitySearch-1772075707557",- "sourceHandle": "output-tool",- "target": "web_agent-1770070863433",- "targetHandle": "input-tools",- "id": "reactflow__edge-perplexitySearch-1772075707557output-tool-web_agent-1770070863433input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "typescriptExecutor-1772075756858",- "sourceHandle": "output-tool",- "target": "coding_agent-1770070861999",- "targetHandle": "input-tools",- "id": "reactflow__edge-typescriptExecutor-1772075756858output-tool-coding_agent-1770070861999input-tools",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "telegramReceive-1772725517789",- "sourceHandle": "output-main",- "target": "chatAgent-1770060581808",- "targetHandle": "input-main",- "id": "reactflow__edge-telegramReceive-1772725517789output-main-chatAgent-1770060581808input-main",- "selected": false- },- {- "type": "smoothstep",- "animated": true,- "style": {- "stroke": "#8be9fd",- "strokeWidth": 3- },- "source": "chatAgent-1770060581808",- "sourceHandle": "output-main",- "target": "telegramSend-1772781380014",- "targetHandle": "input-main",- "id": "reactflow__edge-chatAgent-1770060581808output-main-telegramSend-1772781380014input-main"- }- ],- "createdAt": "2026-03-06T01:21:31.507Z",- "lastModified": "2026-03-06T01:46:42.000Z",- "version": "0.0.43",- "nodeParameters": {- "chatAgent-1770060581808": {- "provider": "gemini",- "model": "gemini-3.1-pro-preview",- "prompt": "{{chattrigger.message}} {{telegramreceive.text}}",- "systemMessage": "You are a helpful assistant."- },- "coding_agent-1770070861999": {- "provider": "gemini",- "model": "gemini-3.1-pro-preview",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant"- },- "web_agent-1770070863433": {- "provider": "gemini",- "model": "gemini-3.1-pro-preview",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant"- },- "masterSkill-1770080471262": {- "skillFolder": "productivity_agent",- "skillsConfig": {- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "calendar-skill": {- "enabled": true,- "instructions": "# Google Calendar Skill\n\nManage Google Calendar events - create, list, update, and delete.\n\n## Tool: google_calendar\n\nConsolidated Google Calendar tool with `operation` parameter.\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `create` | Create a new event | title, start_time, end_time |\n| `list` | List events in date range | (none, defaults to this week) |\n| `update` | Update an existing event | event_id |\n| `delete` | Delete an event | event_id |\n\n### create - Create a new event\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"create\"` |\n| title | string | Yes | Event title/summary |\n| start_time | string | Yes | Start time in ISO 8601 format |\n| end_time | string | Yes | End time in ISO 8601 format |\n| description | string | No | Event description |\n| location | string | No | Event location |\n| attendees | string | No | Comma-separated email addresses |\n| reminder_minutes | integer | No | Minutes before event for reminder |\n| timezone | string | No | Timezone (default: user's timezone) |\n\n**Example - Simple event:**\n```json\n{\n \"operation\": \"create\",\n \"title\": \"Team Meeting\",\n \"start_time\": \"2024-02-01T14:00:00\",\n \"end_time\": \"2024-02-01T15:00:00\",\n \"description\": \"Weekly team sync\"\n}\n```\n\n**Example - Event with attendees:**\n```json\n{\n \"operation\": \"create\",\n \"title\": \"Project Review\",\n \"start_time\": \"2024-02-01T10:00:00\",\n \"end_time\": \"2024-02-01T11:30:00\",\n \"location\": \"Conference Room A\",\n \"attendees\": \"[email protected],[email protected]\",\n \"reminder_minutes\": 30\n}\n```\n\n### list - List events in date range\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"list\"` |\n| start_date | string | No | Start date (ISO 8601, default: today) |\n| end_date | string | No | End date (ISO 8601, default: 7 days ahead) |\n| max_results | integer | No | Maximum results (default: 10, max: 100) |\n| calendar_id | string | No | Calendar ID (default: primary) |\n\n**Example:**\n```json\n{\n \"operation\": \"list\",\n \"start_date\": \"2024-02-01\",\n \"end_date\": \"2024-02-07\",\n \"max_results\": 20\n}\n```\n\n### update - Update an existing event\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"update\"` |\n| event_id | string | Yes | Event ID to update |\n| update_title | string | No | New title |\n| update_start_time | string | No | New start time |\n| update_end_time | string | No | New end time |\n| update_description | string | No | New description |\n| update_location | string | No | New location |\n| update_attendees | string | No | New attendees (replaces existing) |\n\n**Example:**\n```json\n{\n \"operation\": \"update\",\n \"event_id\": \"abc123xyz\",\n \"update_title\": \"Updated Team Meeting\",\n \"update_start_time\": \"2024-02-01T15:00:00\",\n \"update_end_time\": \"2024-02-01T16:00:00\"\n}\n```\n\n### delete - Delete an event\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"delete\"` |\n| event_id | string | Yes | Event ID to delete |\n| calendar_id | string | No | Calendar ID (default: primary) |\n\n**Example:**\n```json\n{\n \"operation\": \"delete\",\n \"event_id\": \"abc123xyz\"\n}\n```\n\n## Date/Time Formats\n\n- **ISO 8601**: `2024-02-01T14:00:00` (local time)\n- **With timezone**: `2024-02-01T14:00:00-05:00` (EST)\n- **UTC**: `2024-02-01T19:00:00Z`\n- **Date only**: `2024-02-01` (all-day event)\n\n## Common Workflows\n\n1. **Schedule a meeting**: Create event with attendees, they receive invites\n2. **Check availability**: List events for a date range\n3. **Reschedule**: Update event with new times\n4. **Cancel meeting**: Delete the event\n\n## Setup Requirements\n\n1. Connect Calendar node to AI Agent's `input-tools` handle\n2. Authenticate with Google Workspace in Credentials Modal\n3. Ensure Calendar API scopes are authorized\n",- "isCustomized": false- },- "contacts-skill": {- "enabled": true,- "instructions": "# Google Contacts Skill\n\nManage Google Contacts - create, list, and search contacts.\n\n## Tool: google_contacts\n\nConsolidated Google Contacts tool with `operation` parameter.\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `create` | Create a new contact | first_name |\n| `list` | List contacts | (none) |\n| `search` | Search contacts by query | query |\n| `get` | Get contact details | resource_name |\n| `update` | Update existing contact | resource_name |\n| `delete` | Delete a contact | resource_name |\n\n### create - Create a new contact\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"create\"` |\n| first_name | string | Yes | Contact's first name |\n| last_name | string | No | Contact's last name |\n| email | string | No | Email address |\n| phone | string | No | Phone number |\n| company | string | No | Company/organization name |\n| job_title | string | No | Job title |\n| notes | string | No | Notes about contact |\n\n**Example - Basic contact:**\n```json\n{\n \"operation\": \"create\",\n \"first_name\": \"John\",\n \"last_name\": \"Smith\",\n \"email\": \"[email protected]\",\n \"phone\": \"+1-555-123-4567\"\n}\n```\n\n**Example - Full contact:**\n```json\n{\n \"operation\": \"create\",\n \"first_name\": \"Jane\",\n \"last_name\": \"Doe\",\n \"email\": \"[email protected]\",\n \"phone\": \"+1-555-987-6543\",\n \"company\": \"Acme Corporation\",\n \"job_title\": \"Senior Engineer\",\n \"notes\": \"Met at tech conference 2024\"\n}\n```\n\n### list - List contacts\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"list\"` |\n| page_size | integer | No | Results per page (default: 20, max: 100) |\n| page_token | string | No | Token for next page |\n| sort_order | string | No | LAST_MODIFIED_ASCENDING, LAST_MODIFIED_DESCENDING, FIRST_NAME_ASCENDING, LAST_NAME_ASCENDING |\n\n**Example:**\n```json\n{\n \"operation\": \"list\",\n \"page_size\": 50,\n \"sort_order\": \"FIRST_NAME_ASCENDING\"\n}\n```\n\n### search - Search contacts\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"search\"` |\n| query | string | Yes | Search query (name or email) |\n| page_size | integer | No | Results per page (default: 10, max: 30) |\n\n**Example - Search by name:**\n```json\n{\n \"operation\": \"search\",\n \"query\": \"John\"\n}\n```\n\n**Example - Search by email domain:**\n```json\n{\n \"operation\": \"search\",\n \"query\": \"@company.com\"\n}\n```\n\n### get - Get contact details\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"get\"` |\n| resource_name | string | Yes | Contact resource name (e.g., \"people/c1234567890\") |\n\n**Example:**\n```json\n{\n \"operation\": \"get\",\n \"resource_name\": \"people/c1234567890\"\n}\n```\n\n### update - Update a contact\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"update\"` |\n| resource_name | string | Yes | Contact resource name |\n| update_first_name | string | No | New first name |\n| update_last_name | string | No | New last name |\n| update_email | string | No | New email |\n| update_phone | string | No | New phone |\n| update_company | string | No | New company |\n| update_job_title | string | No | New job title |\n\n**Example:**\n```json\n{\n \"operation\": \"update\",\n \"resource_name\": \"people/c1234567890\",\n \"update_email\": \"[email protected]\",\n \"update_job_title\": \"Director of Engineering\"\n}\n```\n\n### delete - Delete a contact\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"delete\"` |\n| resource_name | string | Yes | Contact resource name |\n\n**Example:**\n```json\n{\n \"operation\": \"delete\",\n \"resource_name\": \"people/c1234567890\"\n}\n```\n\n## Contact Fields\n\n| Field | Description |\n|-------|-------------|\n| `resource_name` | Unique identifier (people/cXXX) |\n| `display_name` | Full formatted name |\n| `first_name` | Given name |\n| `last_name` | Family name |\n| `email` | Primary email address |\n| `phone` | Primary phone number |\n| `company` | Organization name |\n| `job_title` | Position/title |\n| `notes` | Free-form notes |\n\n## Phone Number Formats\n\nAccepted formats:\n- `+1-555-123-4567` (international)\n- `(555) 123-4567` (US format)\n- `555-123-4567` (simple)\n- `5551234567` (digits only)\n\n## Common Workflows\n\n1. **Add new contact**: Create with basic info after meeting someone\n2. **Find contact**: Search by name to get their details\n3. **Build mailing list**: List contacts, filter by company\n4. **Update CRM**: Export contacts for business use\n\n## Tips\n\n- Search is case-insensitive\n- Partial matches work for names\n- Email search matches any part of address\n- Use page_token for pagination through large lists\n\n## Setup Requirements\n\n1. Connect Contacts node to AI Agent's `input-tools` handle\n2. Authenticate with Google Workspace in Credentials Modal\n3. Ensure People API (Contacts) scopes are authorized\n",- "isCustomized": false- },- "drive-skill": {- "enabled": true,- "instructions": "# Google Drive Skill\n\nManage Google Drive files - upload, download, list, and share.\n\n## Tool: google_drive\n\nConsolidated Google Drive tool with `operation` parameter.\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `upload` | Upload a file to Drive | filename + (file_url or file_content) |\n| `download` | Download a file by ID | file_id |\n| `list` | List/search files | (none, defaults to root) |\n| `share` | Share a file with a user | file_id, email |\n\n### upload - Upload a file\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"upload\"` |\n| file_url | string | Yes* | URL of file to upload |\n| file_content | string | Yes* | Base64 encoded file content |\n| filename | string | Yes | Name for the uploaded file |\n| folder_id | string | No | Destination folder ID (default: root) |\n| mime_type | string | No | File MIME type (auto-detected if not provided) |\n\n*Either `file_url` OR `file_content` is required.\n\n**Example - Upload from URL:**\n```json\n{\n \"operation\": \"upload\",\n \"file_url\": \"https://example.com/report.pdf\",\n \"filename\": \"Q4_Report.pdf\",\n \"folder_id\": \"1abc123def456\"\n}\n```\n\n### download - Download a file\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"download\"` |\n| file_id | string | Yes | File ID to download |\n| output_format | string | No | `\"base64\"` or `\"url\"` (default: base64) |\n\n**Example:**\n```json\n{\n \"operation\": \"download\",\n \"file_id\": \"1xyz789abc\"\n}\n```\n\n### list - List/search files\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"list\"` |\n| folder_id | string | No | Folder ID (default: root) |\n| query | string | No | Drive search query |\n| max_results | integer | No | Maximum results (default: 20, max: 1000) |\n| file_types | string | No | Filter: `\"all\"`, `\"folder\"`, `\"document\"`, `\"spreadsheet\"`, `\"image\"` |\n| order_by | string | No | Sort order (default: `\"modifiedTime desc\"`) |\n\n**Query Syntax:**\n- `name contains 'report'` - Files with \"report\" in name\n- `mimeType = 'application/pdf'` - PDF files only\n- `modifiedTime > '2024-01-01'` - Recently modified\n- `trashed = false` - Exclude trashed files\n\n**Example - Search for PDFs:**\n```json\n{\n \"operation\": \"list\",\n \"query\": \"name contains 'invoice' and mimeType = 'application/pdf'\",\n \"max_results\": 50\n}\n```\n\n### share - Share a file\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"share\"` |\n| file_id | string | Yes | File ID to share |\n| email | string | Yes | Email address to share with |\n| role | string | No | `\"reader\"`, `\"commenter\"`, `\"writer\"` (default: reader) |\n| send_notification | boolean | No | Send email notification (default: true) |\n| message | string | No | Custom notification message |\n\n**Example:**\n```json\n{\n \"operation\": \"share\",\n \"file_id\": \"1xyz789abc\",\n \"email\": \"[email protected]\",\n \"role\": \"writer\"\n}\n```\n\n## Common MIME Types\n\n| Type | MIME Type |\n|------|-----------|\n| PDF | `application/pdf` |\n| Word | `application/vnd.openxmlformats-officedocument.wordprocessingml.document` |\n| Excel | `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet` |\n| PowerPoint | `application/vnd.openxmlformats-officedocument.presentationml.presentation` |\n| Google Doc | `application/vnd.google-apps.document` |\n| Google Sheet | `application/vnd.google-apps.spreadsheet` |\n| Folder | `application/vnd.google-apps.folder` |\n\n## Common Workflows\n\n1. **Backup files**: Upload local files to Drive folder\n2. **Share report**: Upload file, then share with team\n3. **Find files**: List with search query\n4. **Download for processing**: Download, process locally, re-upload\n\n## Setup Requirements\n\n1. Connect Drive node to AI Agent's `input-tools` handle\n2. Authenticate with Google Workspace in Credentials Modal\n3. Ensure Drive API scopes are authorized\n",- "isCustomized": false- },- "gmail-skill": {- "enabled": true,- "instructions": "# Gmail Skill\n\nSend, search, and read emails using Gmail API.\n\n## Tool: google_gmail\n\nConsolidated Gmail tool with `operation` parameter.\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `send` | Send an email | to, subject, body |\n| `search` | Search emails by query | query |\n| `read` | Read email by ID | message_id |\n\n### send - Send an email\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"send\"` |\n| to | string | Yes | Recipient email address |\n| subject | string | Yes | Email subject line |\n| body | string | Yes | Email body (plain text or HTML) |\n| cc | string | No | CC recipients (comma-separated) |\n| bcc | string | No | BCC recipients (comma-separated) |\n| body_type | string | No | `\"text\"` or `\"html\"` (default: text) |\n\n**Example - Send plain text email:**\n```json\n{\n \"operation\": \"send\",\n \"to\": \"[email protected]\",\n \"subject\": \"Meeting Tomorrow\",\n \"body\": \"Hi,\\n\\nJust a reminder about our meeting tomorrow at 2pm.\\n\\nBest regards\"\n}\n```\n\n**Example - Send HTML email:**\n```json\n{\n \"operation\": \"send\",\n \"to\": \"[email protected]\",\n \"subject\": \"Weekly Report\",\n \"body\": \"<h1>Weekly Report</h1><p>Here are the highlights...</p>\",\n \"body_type\": \"html\"\n}\n```\n\n### search - Search emails\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"search\"` |\n| query | string | Yes | Gmail search query |\n| max_results | integer | No | Maximum results (default: 10, max: 100) |\n| include_body | boolean | No | Fetch full message body (default: false) |\n\n**Query Syntax Examples:**\n- `from:[email protected]` - Emails from specific sender\n- `to:[email protected]` - Emails to specific recipient\n- `subject:meeting` - Emails with \"meeting\" in subject\n- `has:attachment` - Emails with attachments\n- `is:unread` - Unread emails\n- `after:2024/01/01` - Emails after date\n- `before:2024/12/31` - Emails before date\n- `label:important` - Emails with label\n- `\"exact phrase\"` - Exact phrase match\n- `from:[email protected] is:unread` - Combine multiple filters\n\n**Example:**\n```json\n{\n \"operation\": \"search\",\n \"query\": \"from:[email protected] has:attachment after:2024/01/01\",\n \"max_results\": 20\n}\n```\n\n### read - Read email content\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"read\"` |\n| message_id | string | Yes | Gmail message ID from search results |\n| format | string | No | `\"full\"`, `\"minimal\"`, `\"raw\"`, `\"metadata\"` (default: full) |\n\n**Example:**\n```json\n{\n \"operation\": \"read\",\n \"message_id\": \"abc123\"\n}\n```\n\n## Common Workflows\n\n1. **Check unread emails**: Search with `is:unread`, then read important ones\n2. **Find emails from someone**: Search with `from:[email protected]`\n3. **Reply to email**: Read the email first, then send with same subject prefixed with \"Re:\"\n4. **Forward email**: Read email, send to new recipient with \"Fwd:\" prefix\n\n## Setup Requirements\n\n1. Connect Gmail node to AI Agent's `input-tools` handle\n2. Authenticate with Google Workspace in Credentials Modal\n3. Ensure Gmail API scopes are authorized\n",- "isCustomized": false- },- "sheets-skill": {- "enabled": true,- "instructions": "# Google Sheets Skill\n\nRead and write data to Google Sheets spreadsheets.\n\n## Tool: google_sheets\n\nConsolidated Google Sheets tool with `operation` parameter.\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `read` | Read data from a range | spreadsheet_id, range |\n| `write` | Write data to a range | spreadsheet_id, range, values |\n| `append` | Append rows to a table | spreadsheet_id, range, values |\n\n### read - Read spreadsheet data\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"read\"` |\n| spreadsheet_id | string | Yes | Spreadsheet ID from URL |\n| range | string | Yes | A1 notation range (e.g., \"Sheet1!A1:D10\") |\n\n**How to find Spreadsheet ID:**\nFrom URL: `https://docs.google.com/spreadsheets/d/SPREADSHEET_ID/edit`\n\n**Range Notation (A1):**\n- `Sheet1!A1:D10` - Specific range on Sheet1\n- `Sheet1!A:D` - Entire columns A through D\n- `Sheet1!1:10` - Rows 1 through 10\n- `A1:D10` - Default sheet, specific range\n- `Sheet1` - Entire sheet\n\n**Example:**\n```json\n{\n \"operation\": \"read\",\n \"spreadsheet_id\": \"1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms\",\n \"range\": \"Sheet1!A1:E10\"\n}\n```\n\n### write - Write data to a range\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"write\"` |\n| spreadsheet_id | string | Yes | Spreadsheet ID |\n| range | string | Yes | A1 notation range |\n| values | array | Yes | 2D array of values |\n| value_input_option | string | No | `\"USER_ENTERED\"` or `\"RAW\"` (default: USER_ENTERED) |\n\n**Example - Write data:**\n```json\n{\n \"operation\": \"write\",\n \"spreadsheet_id\": \"1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms\",\n \"range\": \"Sheet1!A1:C3\",\n \"values\": [\n [\"Name\", \"Score\", \"Grade\"],\n [\"Alice\", 95, \"A\"],\n [\"Bob\", 87, \"B\"]\n ]\n}\n```\n\n**Example - Write formula:**\n```json\n{\n \"operation\": \"write\",\n \"spreadsheet_id\": \"1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms\",\n \"range\": \"Sheet1!D2\",\n \"values\": [[\"=SUM(B2:C2)\"]],\n \"value_input_option\": \"USER_ENTERED\"\n}\n```\n\n### append - Append rows to a table\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"append\"` |\n| spreadsheet_id | string | Yes | Spreadsheet ID |\n| range | string | Yes | Table range (e.g., \"Sheet1!A:E\") |\n| values | array | Yes | 2D array of rows to append |\n| value_input_option | string | No | `\"USER_ENTERED\"` or `\"RAW\"` (default: USER_ENTERED) |\n| insert_data_option | string | No | `\"INSERT_ROWS\"` or `\"OVERWRITE\"` (default: INSERT_ROWS) |\n\n**Example:**\n```json\n{\n \"operation\": \"append\",\n \"spreadsheet_id\": \"1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms\",\n \"range\": \"Sheet1!A:E\",\n \"values\": [\n [\"Charlie\", \"[email protected]\", \"Sales\", \"2024-02-01\", \"Active\"],\n [\"Diana\", \"[email protected]\", \"HR\", \"2024-02-15\", \"Active\"]\n ]\n}\n```\n\n## Common Formulas\n\n| Formula | Description |\n|---------|-------------|\n| `=SUM(A1:A10)` | Sum of range |\n| `=AVERAGE(B1:B10)` | Average of range |\n| `=COUNT(A:A)` | Count numbers in column |\n| `=COUNTA(A:A)` | Count non-empty cells |\n| `=VLOOKUP(E1,A:C,2,FALSE)` | Vertical lookup |\n| `=IF(A1>90,\"A\",\"B\")` | Conditional logic |\n| `=TODAY()` | Current date |\n| `=NOW()` | Current date and time |\n\n## Common Workflows\n\n1. **Import data**: Write headers, then append data rows\n2. **Update records**: Read to find row, write to specific cells\n3. **Generate reports**: Read data, process, write summary\n4. **Log entries**: Append new rows with timestamps\n\n## Tips\n\n- Always check spreadsheet exists before writing\n- Use `USER_ENTERED` for formulas to work\n- Range must match data dimensions\n- Append is safer than write for adding data\n\n## Setup Requirements\n\n1. Connect Sheets node to AI Agent's `input-tools` handle\n2. Authenticate with Google Workspace in Credentials Modal\n3. Ensure Sheets API scopes are authorized\n4. Spreadsheet must be accessible to authenticated account\n",- "isCustomized": false- },- "tasks-skill": {- "enabled": true,- "instructions": "# Google Tasks Skill\n\nManage Google Tasks - create, list, and complete tasks.\n\n## Tool: google_tasks\n\nConsolidated Google Tasks tool with `operation` parameter.\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `create` | Create a new task | title |\n| `list` | List tasks from a list | (none, defaults to @default) |\n| `complete` | Mark task as completed | task_id |\n| `update` | Update an existing task | task_id |\n| `delete` | Delete a task | task_id |\n\n### create - Create a new task\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"create\"` |\n| title | string | Yes | Task title |\n| notes | string | No | Task notes/description |\n| due_date | string | No | Due date (ISO 8601 or YYYY-MM-DD) |\n| tasklist_id | string | No | Task list ID (default: @default) |\n\n**Example - Simple task:**\n```json\n{\n \"operation\": \"create\",\n \"title\": \"Review quarterly report\"\n}\n```\n\n**Example - Task with details:**\n```json\n{\n \"operation\": \"create\",\n \"title\": \"Submit expense report\",\n \"notes\": \"Include receipts for conference travel\",\n \"due_date\": \"2024-02-15\"\n}\n```\n\n### list - List tasks\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"list\"` |\n| tasklist_id | string | No | Task list ID (default: @default) |\n| show_completed | boolean | No | Include completed tasks (default: false) |\n| show_hidden | boolean | No | Include hidden tasks (default: false) |\n| max_results | integer | No | Maximum results (default: 100) |\n\n**Example - List pending tasks:**\n```json\n{\n \"operation\": \"list\",\n \"show_completed\": false,\n \"max_results\": 50\n}\n```\n\n### complete - Mark task as completed\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"complete\"` |\n| task_id | string | Yes | Task ID to complete |\n| tasklist_id | string | No | Task list ID (default: @default) |\n\n**Example:**\n```json\n{\n \"operation\": \"complete\",\n \"task_id\": \"abc123xyz\"\n}\n```\n\n### update - Update a task\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"update\"` |\n| task_id | string | Yes | Task ID to update |\n| tasklist_id | string | No | Task list ID (default: @default) |\n| update_title | string | No | New title |\n| update_notes | string | No | New notes |\n| update_due_date | string | No | New due date |\n| update_status | string | No | New status: `\"needsAction\"` or `\"completed\"` |\n\n**Example:**\n```json\n{\n \"operation\": \"update\",\n \"task_id\": \"abc123xyz\",\n \"update_title\": \"Updated task title\",\n \"update_due_date\": \"2024-03-01\"\n}\n```\n\n### delete - Delete a task\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Must be `\"delete\"` |\n| task_id | string | Yes | Task ID to delete |\n| tasklist_id | string | No | Task list ID (default: @default) |\n\n**Example:**\n```json\n{\n \"operation\": \"delete\",\n \"task_id\": \"abc123xyz\"\n}\n```\n\n## Task Statuses\n\n| Status | Description |\n|--------|-------------|\n| `needsAction` | Task is pending |\n| `completed` | Task is done |\n\n## Date Formats\n\n- **ISO 8601**: `2024-02-15T14:00:00Z`\n- **Date only**: `2024-02-15` (interpreted as midnight UTC)\n\n## Working with Task Lists\n\nThe default task list is `@default`. To work with custom lists:\n\n1. Use Google Tasks app to create lists\n2. Get list ID from API (not exposed in this skill yet)\n3. Pass `tasklist_id` parameter\n\n## Common Workflows\n\n1. **Daily review**: List pending tasks, prioritize\n2. **Add reminders**: Create tasks with due dates\n3. **Track completion**: Mark tasks done as you finish\n4. **Weekly planning**: Create tasks for the week ahead\n\n## Tips\n\n- Tasks without due dates appear at the top of the list\n- Completed tasks are hidden by default\n- Notes can contain multiline text\n- Due dates are in UTC timezone\n\n## Setup Requirements\n\n1. Connect Tasks node to AI Agent's `input-tools` handle\n2. Authenticate with Google Workspace in Credentials Modal\n3. Ensure Tasks API scopes are authorized\n",- "isCustomized": false- }- }- },- "masterSkill-1770193690331": {- "skillFolder": "assistant",- "skillsConfig": {- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "subagent-skill": {- "enabled": true,- "instructions": "# Sub-Agent Management Skill\n\nYou are a parent agent that can delegate tasks to specialized sub-agents. This skill helps you understand, delegate to, and handle results from sub-agents effectively.\n\n## CRITICAL: Always Check Sub-Agents First\n\n**NEVER say \"I don't have that tool\" or \"I can't do that\" without first checking your connected sub-agents.**\n\nWhen a user requests something you don't have a direct tool for:\n\n1. **Check your connected sub-agents** - Look at what agents are available in your tools\n2. **Delegate to the appropriate sub-agent** - They have their own tools and capabilities\n3. **Only say you can't** if NO sub-agent can handle it\n\n**Wrong approach:**\n```\nUser: \"Check my phone battery\"\nYou: \"I don't have access to Android tools, so I can't check your battery.\"\n```\n\n**Correct approach:**\n```\nUser: \"Check my phone battery\"\nYou: [Check if Android Control Agent is connected]\nYou: [Delegate to Android Control Agent: \"Get battery status\"]\nYou: \"Let me check that for you...\" [waits for result]\n```\n\n## Available Sub-Agent Types\n\nYou can delegate tasks to these specialized agents (when connected to your tools):\n\n### Domain-Specific Agents\n\n| Agent | Icon | Specialty | Best For |\n|-------|------|-----------|----------|\n| **Android Control Agent** | 📱 | Android device automation | Battery checks, WiFi control, app launching, location tracking, sensor data |\n| **Coding Agent** | 💻 | Code execution | Python/JavaScript execution, calculations, data processing |\n| **Web Control Agent** | 🌐 | Browser automation | Web scraping, HTTP requests, form filling |\n| **Social Media Agent** | 📱 | Social messaging | WhatsApp, Telegram, multi-platform messaging |\n| **Travel Agent** | ✈️ | Travel planning | Itineraries, location lookups, travel recommendations |\n\n### Task & Workflow Agents\n\n| Agent | Icon | Specialty | Best For |\n|-------|------|-----------|----------|\n| **Task Management Agent** | 📋 | Task automation | Scheduling, reminders, to-do management |\n| **Tool Agent** | 🔧 | Tool orchestration | Multi-tool workflows, complex task execution |\n| **Productivity Agent** | ⏰ | Productivity | Time management, note-taking, workflow automation |\n\n### Business Agents\n\n| Agent | Icon | Specialty | Best For |\n|-------|------|-----------|----------|\n| **Payments Agent** | 💳 | Payment processing | Payment workflows, invoices, financial operations |\n| **Consumer Agent** | 🛒 | Consumer support | Customer service, product recommendations, order management |\n\n## How to Check Sub-Agent Capabilities\n\nBefore responding \"I can't do that\":\n\n1. **List your available tools** - Sub-agents appear as delegation tools\n2. **Match the request to an agent specialty** - Use the table above\n3. **Delegate if a match exists** - The sub-agent has its own tools\n4. **Only decline if truly impossible** - No matching agent connected\n\n### Capability Matching Examples\n\n| User Request | Check For | Delegate To |\n|--------------|-----------|-------------|\n| \"Check my battery\" | Android Control Agent | `delegate_to_android_agent` |\n| \"Send a WhatsApp\" | Social Media Agent | `delegate_to_social_agent` |\n| \"Calculate this\" | Coding Agent | `delegate_to_coding_agent` |\n| \"Find restaurants nearby\" | Travel Agent | `delegate_to_travel_agent` |\n| \"Make an HTTP request\" | Web Control Agent | `delegate_to_web_agent` |\n| \"Set a reminder\" | Task Management Agent | `delegate_to_task_agent` |\n\n## How Delegation Works\n\n### Fire-and-Forget Pattern\nWhen you delegate a task:\n1. The sub-agent receives the task and starts working immediately\n2. You continue your conversation - delegation is non-blocking\n3. The sub-agent works independently with its own tools and memory\n4. When complete, a `task_completed` event is fired\n\n### What You Receive Back\n- **Task ID**: Unique identifier (e.g., `delegated_abc123_xyz`)\n- **Status**: `completed` or `error`\n- **Agent Name**: Which sub-agent completed the work\n- **Result/Error**: The outcome or error message\n\n## Delegation Best Practices\n\n### When to Delegate\n- User requests something outside your direct tools\n- Task requires specialized capabilities (Android, WhatsApp, code execution, etc.)\n- Task is time-consuming and can run in background\n- Task matches a sub-agent's specialty area\n\n### When NOT to Delegate\n- Simple questions you can answer directly from knowledge\n- Tasks that need immediate response AND you have the direct tool\n- When the same task is already running (avoid duplicates)\n\n### Delegation Format\nWhen delegating, provide clear instructions:\n```\nTask: [Clear description of what needs to be done]\nContext: [Any relevant background information]\nExpected Output: [What format/information you need back]\n```\n\n## Handling Task Completion\n\n### Successful Completion\nWhen a delegated task completes successfully:\n\n1. **DO NOT delegate again** - The task is finished\n2. **Extract key information** from the result\n3. **Report to the user** naturally and conversationally\n4. **Suggest next steps** if appropriate\n\n**Example Response:**\n\"The Android agent has checked your battery status. Your device is at 78% with approximately 5 hours of usage remaining. Would you like me to enable power-saving mode?\"\n\n### Failed Tasks\nWhen a delegated task fails:\n\n1. **DO NOT retry automatically** - Let the user decide\n2. **Explain what went wrong** clearly\n3. **Suggest alternatives** or troubleshooting steps\n\n**Example Response:**\n\"I wasn't able to send the WhatsApp message because the contact wasn't found. Could you verify the phone number? Alternatively, I can try searching for the contact by name.\"\n\n## Multi-Agent Coordination\n\n### Sequential Delegation\nFor tasks requiring multiple steps:\n1. Delegate first task to appropriate agent\n2. Wait for completion via task trigger\n3. Use result to delegate next task\n4. Continue until workflow complete\n\n### Parallel Delegation\nFor independent tasks:\n- Delegate multiple tasks to different agents\n- Each runs independently\n- Collect results as they complete\n\n## Critical Rules\n\n1. **ALWAYS check sub-agents before saying \"I can't\"** - They extend your capabilities\n2. **NEVER re-delegate after receiving a result** - Report it instead\n3. **NEVER retry failed tasks automatically** - Ask user first\n4. **ALWAYS acknowledge task completion** to the user\n5. **ALWAYS match task to agent specialty** for best results\n\n## Error Handling\n\n| Error Type | Action |\n|------------|--------|\n| Agent not connected | Inform user which agent is needed and how to connect it |\n| Task timeout | Report to user, suggest retry |\n| Invalid parameters | Clarify requirements with user |\n| Agent error | Report error details, suggest alternatives |\n\n## Example Workflows\n\n### Battery Check Workflow\n```\nUser: \"Check my phone battery\"\nYou: [See Android Control Agent in tools]\nYou: Delegate to Android Control Agent with task \"Get battery status\"\nAgent: Returns {status: 'completed', result: 'Battery at 78%, charging'}\nYou: \"Your phone battery is at 78% and currently charging.\"\n```\n\n### Message Sending Workflow\n```\nUser: \"Send a WhatsApp to John saying I'll be late\"\nYou: [See Social Media Agent in tools]\nYou: Delegate to Social Media Agent with message details\nAgent: Returns {status: 'completed', result: 'Message sent to John'}\nYou: \"Done! I've sent the message to John letting him know you'll be late.\"\n```\n\n### No Agent Available\n```\nUser: \"Check my phone battery\"\nYou: [No Android Control Agent in tools]\nYou: \"I don't have an Android Control Agent connected right now. To check your battery, please connect an Android Control Agent to my tools input, then ask again.\"\n```\n",- "isCustomized": false- }- }- },- "masterSkill-1770193844078": {- "skillFolder": "web_agent",- "skillsConfig": {- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "brave-search-skill": {- "enabled": true,- "instructions": "# Brave Search Skill\n\nSearch the web using the Brave Search API. Brave Search is a privacy-focused, independent search engine that does not track users or profile them.\n\n## How It Works\n\nThis skill provides instructions and context. To execute searches, connect the **Brave Search** node to the agent's `input-tools` handle.\n\n## brave_search Tool\n\nSearch the web and get relevant results from Brave's independent index.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| query | string | Yes | Search query to look up on the web |\n\n### Node Parameters\n\nAdditional options configured on the node:\n\n| Parameter | Default | Description |\n|-----------|---------|-------------|\n| maxResults | 10 | Number of results to return (max 100) |\n| country | (empty) | Country code for regional results (e.g., US, GB, DE) |\n| searchLang | (empty) | Language code for search results (e.g., en, es, fr) |\n| safeSearch | moderate | Safe search filtering: off, moderate, strict |\n\n### Response Format\n\n```json\n{\n \"query\": \"artificial intelligence news\",\n \"results\": [\n {\n \"title\": \"AI Breakthrough in Medical Research\",\n \"snippet\": \"Researchers have developed a new AI model that can predict...\",\n \"url\": \"https://example.com/ai-medical-research\"\n }\n ],\n \"result_count\": 10,\n \"provider\": \"brave_search\"\n}\n```\n\n### Examples\n\n**General search:**\n```json\n{\n \"query\": \"latest news about artificial intelligence\"\n}\n```\n\n**Technical search:**\n```json\n{\n \"query\": \"Python asyncio best practices 2026\"\n}\n```\n\n**Local search:**\n```json\n{\n \"query\": \"best restaurants in San Francisco\"\n}\n```\n\n## When to Use Brave Search\n\n- **Privacy-focused results** - No user tracking or profiling\n- **Independent index** - Not reliant on Google or Bing\n- **General web search** - News, facts, documentation, products\n- **Regional results** - Use country/language parameters for localized results\n\n## When NOT to Use Brave Search\n\n- **AI-powered answers** - Use Perplexity instead for synthesized answers with citations\n- **Google-specific results** - Use Serper for Google's index\n- **Simple calculations** - Use the calculator tool\n- **Creative tasks** - Writing, brainstorming, analysis\n\n## Search Query Best Practices\n\n- Use specific, focused queries (under 10 words when possible)\n- Include relevant keywords, dates, and context\n- Break complex questions into simpler searches\n- Avoid filler words like \"please\" or \"can you tell me\"\n\n## API Details\n\n- **API**: GET `https://api.search.brave.com/res/v1/web/search`\n- **Auth**: `X-Subscription-Token` header\n- **Rate Limits**: Depends on plan (Free: 1 query/sec, 2000/month)\n- **Pricing**: ~$0.003 per query\n\n## Setup Requirements\n\n1. Connect this skill to the agent's `input-skill` handle\n2. Connect the **Brave Search** node to the agent's `input-tools` handle\n3. Add your Brave Search API key in Credentials > Search\n",- "isCustomized": false- },- "duckduckgo-search-skill": {- "enabled": true,- "instructions": "# DuckDuckGo Search Skill\n\nThis skill enables free web search via DuckDuckGo. No API key required.\n\nFor premium search providers, see the dedicated skills:\n- **brave-search-skill** - Brave Search API (independent index, privacy-focused)\n- **serper-search-skill** - Serper API (Google-powered, news/images/places)\n- **perplexity-search-skill** - Perplexity Sonar AI (synthesized answers with citations)\n\n## How It Works\n\nThis skill provides instructions and context. To execute web searches, connect the **DuckDuckGo Search** node to the agent's `input-tools` handle.\n\n## web_search Tool\n\nSearch the web using DuckDuckGo and get relevant results.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| query | string | Yes | The search query to look up on the web |\n\n### Node Parameters\n\n| Parameter | Default | Description |\n|-----------|---------|-------------|\n| maxResults | 5 | Number of results to return |\n\n### Examples\n\n**Basic search:**\n```json\n{\n \"query\": \"latest news about artificial intelligence\"\n}\n```\n\n**Factual search:**\n```json\n{\n \"query\": \"population of Tokyo 2024\"\n}\n```\n\n**Current events:**\n```json\n{\n \"query\": \"weather forecast New York today\"\n}\n```\n\n**Technical search:**\n```json\n{\n \"query\": \"how to use Python asyncio gather\"\n}\n```\n\n### Response Format\n\n```json\n{\n \"query\": \"artificial intelligence news\",\n \"results\": [\n {\n \"title\": \"AI Breakthrough in Medical Research\",\n \"snippet\": \"Researchers have developed a new AI model that can predict...\",\n \"url\": \"https://example.com/ai-medical-research\"\n },\n {\n \"title\": \"OpenAI Announces New Model\",\n \"snippet\": \"The company revealed its latest advancement in...\",\n \"url\": \"https://example.com/openai-announcement\"\n }\n ],\n \"provider\": \"duckduckgo\"\n}\n```\n\n## When to Use DuckDuckGo Search\n\nUse DuckDuckGo search when the user asks about:\n\n1. **Current events and news** - Recent happenings, breaking news, current affairs\n2. **Real-time data** - Stock prices, weather, sports scores, exchange rates\n3. **Recent information** - Events, releases, or changes after your knowledge cutoff\n4. **Specific facts** - Population, statistics, dates that may have changed\n5. **Technical documentation** - Latest API docs, library versions, tutorials\n6. **Local information** - Business hours, addresses, phone numbers\n7. **Product information** - Prices, availability, reviews\n\n## When NOT to Use DuckDuckGo Search\n\nAvoid searching when:\n\n1. **General knowledge** - Well-established facts that won't change\n2. **Simple calculations** - Use the calculator tool instead\n3. **Creative tasks** - Writing, brainstorming, analysis\n4. **Personal advice** - Relationship, life decisions\n5. **Subjective opinions** - Preferences, recommendations without factual basis\n\n## Choosing the Right Search Provider\n\n| Need | Recommended Provider | Tool Node |\n|------|---------------------|-----------|\n| Free search, no API key | DuckDuckGo | DuckDuckGo Search |\n| Google-quality results | Serper | Serper Search |\n| News, images, places | Serper | Serper Search |\n| Privacy-focused, independent | Brave | Brave Search |\n| AI-synthesized answers | Perplexity | Perplexity Search |\n| Research with citations | Perplexity | Perplexity Search |\n\n## Search Query Best Practices\n\n### Do:\n- Use specific, focused queries\n- Include relevant keywords\n- Add context like dates, locations, or names\n- Break complex questions into simpler searches\n\n### Don't:\n- Use overly long queries (keep under 10 words when possible)\n- Include unnecessary words like \"please\" or \"can you tell me\"\n- Ask questions as full sentences (use keywords instead)\n\n### Examples of Good vs Bad Queries\n\n| Bad Query | Good Query |\n|-----------|------------|\n| \"Can you please tell me what the weather is like in London today?\" | \"London weather today\" |\n| \"I want to know about the latest iPhone model and its features\" | \"iPhone 16 Pro specifications\" |\n| \"What is happening in the stock market right now?\" | \"stock market news today\" |\n\n## Handling Results\n\n1. **Summarize** the key findings from search results\n2. **Cite sources** when providing specific information\n3. **Indicate uncertainty** if results are conflicting or unclear\n4. **Suggest follow-up searches** if the initial results are insufficient\n5. **Combine multiple searches** for comprehensive answers\n\n## Limitations\n\n- DuckDuckGo uses the `ddgs` library (free, no API key)\n- Results depend on DuckDuckGo's index\n- Some recent events may not be indexed immediately\n- Paywalled content may show limited snippets\n- Results are in English by default\n\n## Setup Requirements\n\n1. Connect this skill to the agent's `input-skill` handle\n2. Connect the **DuckDuckGo Search** node to the agent's `input-tools` handle\n3. No API key required for DuckDuckGo\n",- "isCustomized": false- },- "http-request-skill": {- "enabled": true,- "instructions": "# HTTP Request Tool\n\nMake HTTP requests to external APIs and web services.\n\n## How It Works\n\nThis skill provides instructions for the **HTTP Request** tool node. Connect the **HTTP Request** node to Zeenie's `input-tools` handle to enable API calls.\n\n## http_request Tool\n\nMake an HTTP request to any URL.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| url | string | Yes | Full URL to request (e.g., `https://api.example.com/data`) |\n| method | string | No | HTTP method: `GET`, `POST`, `PUT`, `DELETE`, `PATCH` (default: `GET`) |\n| body | object | No | Request body as JSON object (for POST/PUT/PATCH) |\n\n### Node Parameters\n\nAdditional options can be configured on the node:\n\n| Parameter | Description |\n|-----------|-------------|\n| headers | Custom headers as JSON (e.g., `{\"Authorization\": \"Bearer token\"}`) |\n| base_url | Base URL prepended to the url parameter |\n\n### Response Format\n\n```json\n{\n \"status\": 200,\n \"data\": { \"key\": \"value\" },\n \"url\": \"https://api.example.com/data\",\n \"method\": \"GET\"\n}\n```\n\n### Examples\n\n**GET request (fetch data):**\n```json\n{\n \"url\": \"https://api.example.com/users/123\",\n \"method\": \"GET\"\n}\n```\n\n**POST request (create resource):**\n```json\n{\n \"url\": \"https://api.example.com/users\",\n \"method\": \"POST\",\n \"body\": {\n \"name\": \"John Doe\",\n \"email\": \"[email protected]\"\n }\n}\n```\n\n**PUT request (update resource):**\n```json\n{\n \"url\": \"https://api.example.com/users/123\",\n \"method\": \"PUT\",\n \"body\": {\n \"name\": \"John Updated\"\n }\n}\n```\n\n**DELETE request:**\n```json\n{\n \"url\": \"https://api.example.com/users/123\",\n \"method\": \"DELETE\"\n}\n```\n\n**PATCH request (partial update):**\n```json\n{\n \"url\": \"https://api.example.com/users/123\",\n \"method\": \"PATCH\",\n \"body\": {\n \"status\": \"active\"\n }\n}\n```\n\n### Real-World Examples\n\n**Get Bitcoin price:**\n```json\n{\n \"url\": \"https://api.coindesk.com/v1/bpi/currentprice.json\",\n \"method\": \"GET\"\n}\n```\n\n**Get weather:**\n```json\n{\n \"url\": \"https://api.openweathermap.org/data/2.5/weather?q=London&appid=YOUR_KEY\",\n \"method\": \"GET\"\n}\n```\n\n**Post to webhook:**\n```json\n{\n \"url\": \"https://hooks.slack.com/services/xxx\",\n \"method\": \"POST\",\n \"body\": {\n \"text\": \"Hello from MachinaOS!\"\n }\n}\n```\n\n**Check website status:**\n```json\n{\n \"url\": \"https://example.com\",\n \"method\": \"GET\"\n}\n```\n\n### Error Responses\n\n**Timeout:**\n```json\n{\n \"error\": \"Request timed out\"\n}\n```\n\n**Connection failed:**\n```json\n{\n \"error\": \"Connection failed: Unable to reach host\"\n}\n```\n\n**HTTP error:**\n```json\n{\n \"status\": 404,\n \"data\": \"Not Found\",\n \"url\": \"https://api.example.com/missing\",\n \"method\": \"GET\"\n}\n```\n\n## HTTP Status Codes\n\n| Status | Meaning | Action |\n|--------|---------|--------|\n| 200-299 | Success | Process the response data |\n| 400 | Bad Request | Check request parameters |\n| 401 | Unauthorized | Check API key/authentication |\n| 403 | Forbidden | Insufficient permissions |\n| 404 | Not Found | Check URL path |\n| 429 | Too Many Requests | Rate limited, wait and retry |\n| 500-599 | Server Error | External service issue |\n\n## Use Cases\n\n| Use Case | Method | Description |\n|----------|--------|-------------|\n| Fetch data | GET | Retrieve resources |\n| Create resource | POST | Add new data |\n| Update resource | PUT/PATCH | Modify existing data |\n| Delete resource | DELETE | Remove data |\n| Health check | GET | Verify service availability |\n| Webhook trigger | POST | Send events to services |\n\n## Guidelines\n\n1. **URLs**: Must be fully qualified with protocol (https://)\n2. **Authentication**: Use node headers for API keys/tokens\n3. **Timeout**: Default 30 seconds\n4. **JSON body**: Automatically serialized for POST/PUT/PATCH\n5. **Response**: JSON responses are automatically parsed\n\n## Security Notes\n\n1. Never expose API keys in responses to users\n2. Validate URLs before making requests\n3. Avoid internal/private network addresses (localhost, 192.168.x.x)\n4. Respect rate limits of external services\n5. Don't store sensitive data from API responses\n\n## Setup Requirements\n\n1. Connect the **HTTP Request** node to Zeenie's `input-tools` handle\n2. Configure authentication headers on the node if needed\n3. Ensure network access to target APIs\n",- "isCustomized": false- },- "perplexity-search-skill": {- "enabled": true,- "instructions": "# Perplexity Search Skill\n\nSearch the web using Perplexity's Sonar AI models. Unlike traditional search engines that return links, Perplexity provides synthesized AI-generated answers with inline citations and source URLs.\n\n## How It Works\n\nThis skill provides instructions and context. To execute searches, connect the **Perplexity Search** node to the agent's `input-tools` handle.\n\n## perplexity_search Tool\n\nAsk a question and get an AI-synthesized answer with citations.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| query | string | Yes | Question or search query to get AI-powered answer with citations |\n\n### Node Parameters\n\nAdditional options configured on the node:\n\n| Parameter | Default | Description |\n|-----------|---------|-------------|\n| model | sonar | Model: sonar (fast), sonar-pro (deeper research) |\n| searchRecencyFilter | (empty) | Filter results by recency: month, week, day, hour |\n| returnImages | false | Include relevant images in response |\n| returnRelatedQuestions | false | Include follow-up question suggestions |\n\n### Response Format\n\n```json\n{\n \"query\": \"What are the latest developments in quantum computing?\",\n \"answer\": \"Recent developments in quantum computing include several significant breakthroughs. **Google's Willow chip** demonstrated error correction below the threshold needed for reliable quantum computation [1]. **IBM** released its 1,121-qubit Condor processor [2], while **Microsoft** announced a new topological qubit approach [3].\\n\\nKey areas of progress:\\n- Error correction advances\\n- Increased qubit counts\\n- New materials and architectures\\n- Growing commercial applications\",\n \"citations\": [\n \"https://blog.google/technology/research/quantum-computing-willow/\",\n \"https://research.ibm.com/blog/condor-processor\",\n \"https://azure.microsoft.com/en-us/blog/quantum/\"\n ],\n \"results\": [\n {\"url\": \"https://blog.google/technology/research/quantum-computing-willow/\"},\n {\"url\": \"https://research.ibm.com/blog/condor-processor\"},\n {\"url\": \"https://azure.microsoft.com/en-us/blog/quantum/\"}\n ],\n \"model\": \"sonar\",\n \"provider\": \"perplexity\",\n \"images\": [],\n \"related_questions\": [\n \"What is quantum error correction?\",\n \"How many qubits does a useful quantum computer need?\"\n ]\n}\n```\n\n### Examples\n\n**Research question:**\n```json\n{\n \"query\": \"What are the latest developments in quantum computing?\"\n}\n```\n\n**Technical question:**\n```json\n{\n \"query\": \"How does React Server Components work in Next.js 15?\"\n}\n```\n\n**Current events:**\n```json\n{\n \"query\": \"What happened at the latest AI safety summit?\"\n}\n```\n\n**Comparison:**\n```json\n{\n \"query\": \"Compare PostgreSQL vs MySQL for large-scale applications\"\n}\n```\n\n## When to Use Perplexity Search\n\n- **Research questions** - Get synthesized, well-structured answers with citations\n- **Technical explanations** - Detailed answers about how things work\n- **Current events analysis** - AI-summarized coverage of recent events\n- **Comparison queries** - Side-by-side analysis of options\n- **Complex topics** - Multi-faceted questions that benefit from AI synthesis\n- **When you need citations** - Every claim backed by source URLs\n\n## When NOT to Use Perplexity Search\n\n- **Simple factual lookups** - Use Brave or Serper for quick facts\n- **Image search** - Use Serper with searchType \"images\"\n- **Local business search** - Use Serper with searchType \"places\"\n- **High-volume queries** - Perplexity costs more per query ($0.005)\n- **Simple calculations** - Use the calculator tool\n\n## Key Differences from Traditional Search\n\n| Aspect | Traditional Search (Brave/Serper) | Perplexity Sonar |\n|--------|----------------------------------|-----------------|\n| Output | List of links with snippets | AI-written answer with inline citations |\n| Format | title + snippet + URL | Full markdown answer with [1][2] references |\n| Best for | Quick lookups, browsing | Research, explanations, synthesis |\n| Speed | Faster | Slightly slower (AI generation) |\n| Cost | $0.001-0.003/query | $0.005/query |\n\n## Answer Format\n\nThe `answer` field contains rich markdown:\n- **Bold text** for emphasis\n- Numbered citations [1][2] referencing the `citations` array\n- Bullet points and lists for structured information\n- Headers for organized sections\n- Code blocks for technical content\n\n## API Details\n\n- **API**: POST `https://api.perplexity.ai/chat/completions`\n- **Auth**: `Authorization: Bearer` header\n- **Models**: `sonar` (fast, default), `sonar-pro` (deeper research)\n- **Timeout**: 60 seconds (AI generation takes longer than traditional search)\n- **Pricing**: ~$0.005 per request\n\n## Setup Requirements\n\n1. Connect this skill to the agent's `input-skill` handle\n2. Connect the **Perplexity Search** node to the agent's `input-tools` handle\n3. Add your Perplexity API key in Credentials > Search\n",- "isCustomized": false- },- "serper-search-skill": {- "enabled": true,- "instructions": "# Serper Search Skill\n\nSearch the web using the Serper API, which provides Google Search results via a simple API. Supports web search, news, images, and places.\n\n## How It Works\n\nThis skill provides instructions and context. To execute searches, connect the **Serper Search** node to the agent's `input-tools` handle.\n\n## serper_search Tool\n\nSearch Google via Serper API and get structured results.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| query | string | Yes | Search query to look up on Google |\n\n### Node Parameters\n\nAdditional options configured on the node:\n\n| Parameter | Default | Description |\n|-----------|---------|-------------|\n| maxResults | 10 | Number of results to return (max 100) |\n| searchType | search | Type: search (web), news, images, places |\n| country | (empty) | Country code for regional results (gl parameter) |\n| language | (empty) | Language code for results (hl parameter) |\n\n### Response Format\n\n**Web search:**\n```json\n{\n \"query\": \"artificial intelligence news\",\n \"results\": [\n {\n \"title\": \"AI Breakthrough in Medical Research\",\n \"snippet\": \"Researchers have developed a new AI model...\",\n \"url\": \"https://example.com/ai-research\",\n \"position\": 1\n }\n ],\n \"result_count\": 10,\n \"search_type\": \"search\",\n \"provider\": \"serper\",\n \"knowledge_graph\": {\n \"title\": \"Artificial Intelligence\",\n \"description\": \"...\"\n }\n}\n```\n\n**News search:**\n```json\n{\n \"query\": \"technology news today\",\n \"results\": [\n {\n \"title\": \"Tech Industry Update\",\n \"snippet\": \"Major developments in...\",\n \"url\": \"https://example.com/news\",\n \"date\": \"2 hours ago\",\n \"source\": \"TechCrunch\"\n }\n ],\n \"search_type\": \"news\",\n \"provider\": \"serper\"\n}\n```\n\n**Images search:**\n```json\n{\n \"query\": \"aurora borealis photos\",\n \"results\": [\n {\n \"title\": \"Northern Lights Over Iceland\",\n \"imageUrl\": \"https://example.com/image.jpg\",\n \"url\": \"https://example.com/gallery\"\n }\n ],\n \"search_type\": \"images\",\n \"provider\": \"serper\"\n}\n```\n\n**Places search:**\n```json\n{\n \"query\": \"coffee shops near me\",\n \"results\": [\n {\n \"title\": \"Blue Bottle Coffee\",\n \"address\": \"123 Main St, San Francisco, CA\",\n \"rating\": 4.5,\n \"url\": \"https://bluebottlecoffee.com\"\n }\n ],\n \"search_type\": \"places\",\n \"provider\": \"serper\"\n}\n```\n\n### Examples\n\n**Web search:**\n```json\n{\n \"query\": \"Python 3.13 new features\"\n}\n```\n\n**News search** (set searchType to \"news\" on node):\n```json\n{\n \"query\": \"stock market today\"\n}\n```\n\n**Places search** (set searchType to \"places\" on node):\n```json\n{\n \"query\": \"Italian restaurants in Manhattan\"\n}\n```\n\n## When to Use Serper Search\n\n- **Google-quality results** - Powered by Google's search index\n- **News search** - Set searchType to \"news\" for current headlines with sources and dates\n- **Image search** - Set searchType to \"images\" for visual content\n- **Places/Local search** - Set searchType to \"places\" for business listings with ratings\n- **Knowledge Graph** - Includes Google Knowledge Graph data when available\n\n## When NOT to Use Serper Search\n\n- **AI-powered answers** - Use Perplexity instead for synthesized answers\n- **Privacy-focused search** - Use Brave Search instead\n- **Simple calculations** - Use the calculator tool\n- **Creative tasks** - Writing, brainstorming, analysis\n\n## Search Query Best Practices\n\n- Use specific, focused queries (under 10 words when possible)\n- Include relevant keywords, dates, and context\n- Use Google search operators: `site:`, `filetype:`, `intitle:`, `-exclude`\n- Break complex questions into simpler searches\n\n## API Details\n\n- **API**: POST `https://google.serper.dev/search` (also /news, /images, /places)\n- **Auth**: `X-API-KEY` header\n- **Pricing**: ~$0.001 per query (one of the cheapest Google SERP APIs)\n\n## Setup Requirements\n\n1. Connect this skill to the agent's `input-skill` handle\n2. Connect the **Serper Search** node to the agent's `input-tools` handle\n3. Add your Serper API key in Credentials > Scrapers\n",- "isCustomized": false- },- "apify-skill": {- "enabled": true,- "instructions": "# Apify Web Scraping Skill\n\nRun pre-built web scrapers (Actors) to extract data from websites and social media platforms.\n\n## How It Works\n\nThis skill provides instructions for the **Apify Actor** tool node. Connect the **Apify Actor** node to Zeenie's `input-tools` handle to enable web scraping capabilities.\n\n## apify_run_actor Tool\n\nRun any Apify actor and retrieve scraped results.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| actor_id | string | Yes | Actor ID from Apify Store (e.g., `apify/instagram-scraper`) |\n| input_json | string | No | Actor input as JSON string (default: `{}`) |\n| max_results | integer | No | Maximum items to return (default: 100) |\n\n### Popular Actors\n\n| Platform | Actor ID | Use Case |\n|----------|----------|----------|\n| Instagram | `apify/instagram-scraper` | Profiles, posts, hashtags, comments |\n| TikTok | `clockworks/tiktok-scraper` | Videos, profiles, trends, hashtags |\n| Twitter/X | `apidojo/tweet-scraper` | Tweets, profiles, search results |\n| LinkedIn | `curious_coder/linkedin-profile-scraper` | Profiles, companies |\n| Facebook | `apify/facebook-posts-scraper` | Posts, pages, groups |\n| YouTube | `apify/youtube-scraper` | Videos, channels, comments |\n| Google Search | `apify/google-search-scraper` | SERP results, organic listings |\n| Google Maps | `apify/google-maps-scraper` | Places, reviews, business info |\n| Web Crawler | `apify/website-content-crawler` | Any website content |\n| Web Scraper | `apify/web-scraper` | Custom scraping with selectors |\n\n### Response Format\n\n```json\n{\n \"run_id\": \"abc123xyz\",\n \"actor_id\": \"apify/instagram-scraper\",\n \"status\": \"SUCCEEDED\",\n \"items\": [\n { \"id\": \"123\", \"text\": \"Post content...\", \"likes\": 500 }\n ],\n \"item_count\": 50,\n \"dataset_id\": \"dataset-id-here\",\n \"compute_units\": 0.5,\n \"started_at\": \"2026-02-23T10:00:00Z\",\n \"finished_at\": \"2026-02-23T10:02:30Z\"\n}\n```\n\n### Examples\n\n**Scrape Instagram profile:**\n```json\n{\n \"actor_id\": \"apify/instagram-scraper\",\n \"input_json\": \"{\\\"directUrls\\\": [\\\"https://instagram.com/natgeo\\\"], \\\"resultsLimit\\\": 50}\",\n \"max_results\": 50\n}\n```\n\n**Search TikTok hashtag:**\n```json\n{\n \"actor_id\": \"clockworks/tiktok-scraper\",\n \"input_json\": \"{\\\"hashtags\\\": [\\\"trending\\\", \\\"fyp\\\"], \\\"resultsPerPage\\\": 30}\",\n \"max_results\": 30\n}\n```\n\n**Search Twitter/X:**\n```json\n{\n \"actor_id\": \"apidojo/tweet-scraper\",\n \"input_json\": \"{\\\"searchTerms\\\": [\\\"AI automation\\\"], \\\"maxItems\\\": 100}\",\n \"max_results\": 100\n}\n```\n\n**Google Search:**\n```json\n{\n \"actor_id\": \"apify/google-search-scraper\",\n \"input_json\": \"{\\\"queries\\\": \\\"best AI tools 2026\\\", \\\"maxPagesPerQuery\\\": 3}\",\n \"max_results\": 30\n}\n```\n\n**Crawl website content:**\n```json\n{\n \"actor_id\": \"apify/website-content-crawler\",\n \"input_json\": \"{\\\"startUrls\\\": [{\\\"url\\\": \\\"https://docs.example.com\\\"}], \\\"maxCrawlDepth\\\": 2, \\\"maxCrawlPages\\\": 50}\",\n \"max_results\": 50\n}\n```\n\n**Scrape Google Maps places:**\n```json\n{\n \"actor_id\": \"apify/google-maps-scraper\",\n \"input_json\": \"{\\\"searchStringsArray\\\": [\\\"restaurants in San Francisco\\\"], \\\"maxCrawledPlaces\\\": 20}\",\n \"max_results\": 20\n}\n```\n\n## Common Input Parameters by Actor\n\n### Instagram Scraper\n| Parameter | Type | Description |\n|-----------|------|-------------|\n| directUrls | array | Instagram URLs to scrape |\n| resultsLimit | number | Max results per URL (1-1000) |\n| maxComments | number | Comments per post (0-100) |\n| searchType | string | Type of search: `hashtag`, `user`, `place` |\n\n### TikTok Scraper\n| Parameter | Type | Description |\n|-----------|------|-------------|\n| profiles | array | TikTok usernames to scrape |\n| hashtags | array | Hashtags to scrape (without #) |\n| resultsPerPage | number | Results per request |\n\n### Twitter/X Scraper\n| Parameter | Type | Description |\n|-----------|------|-------------|\n| searchTerms | array | Search queries or hashtags |\n| twitterHandles | array | Usernames (without @) |\n| maxItems | number | Maximum tweets to fetch |\n\n### Google Search Scraper\n| Parameter | Type | Description |\n|-----------|------|-------------|\n| queries | string | Search query |\n| maxPagesPerQuery | number | Pages to scrape (10 results/page) |\n| languageCode | string | Language filter (e.g., `en`) |\n| countryCode | string | Country filter (e.g., `us`) |\n\n### Website Content Crawler\n| Parameter | Type | Description |\n|-----------|------|-------------|\n| startUrls | array | URLs to crawl from (objects with `url` key) |\n| maxCrawlDepth | number | Link depth (0 = start URLs only) |\n| maxCrawlPages | number | Total pages limit |\n\n## Error Responses\n\n**Actor not found:**\n```json\n{\n \"success\": false,\n \"error\": \"Actor 'invalid/actor-id' not found\"\n}\n```\n\n**Timeout:**\n```json\n{\n \"success\": false,\n \"error\": \"Actor run timed out after 300 seconds\"\n}\n```\n\n**Run failed:**\n```json\n{\n \"success\": false,\n \"error\": \"Actor run failed with status FAILED\"\n}\n```\n\n## Run Status Values\n\n| Status | Meaning |\n|--------|---------|\n| SUCCEEDED | Run completed successfully |\n| FAILED | Run encountered an error |\n| ABORTED | Run was manually stopped |\n| TIMED-OUT | Run exceeded timeout limit |\n| RUNNING | Run still in progress |\n\n## Use Cases\n\n| Use Case | Actor | Description |\n|----------|-------|-------------|\n| Social listening | tweet-scraper | Monitor brand mentions |\n| Competitor research | instagram-scraper | Analyze competitor posts |\n| Lead generation | linkedin-profile-scraper | Extract business contacts |\n| SEO research | google-search-scraper | Analyze SERP rankings |\n| Content aggregation | website-content-crawler | Collect articles from sites |\n| Price monitoring | web-scraper | Track product prices |\n| Review analysis | google-maps-scraper | Gather customer reviews |\n\n## Guidelines\n\n1. **Actor IDs**: Use format `username/actor-name` from Apify Store\n2. **Input JSON**: Must be valid JSON string with actor-specific parameters\n3. **Timeouts**: Default 300 seconds, configurable on the node\n4. **Max Results**: Limits items returned (not items scraped)\n5. **Memory**: Higher memory = faster execution, higher cost\n\n## Pricing Notes\n\nApify uses compute units (CU) based on memory and duration:\n- CU = Memory (GB) x Duration (hours)\n- Free tier: $5/month credits\n- Check actor pricing on Apify Store before large scrapes\n\n## Setup Requirements\n\n1. Connect the **Apify Actor** node to Zeenie's `input-tools` handle\n2. Configure your Apify API token in Credentials Modal\n3. Select an actor or enter custom actor ID\n4. Provide actor-specific input as JSON\n\n## Security Notes\n\n1. Respect website terms of service\n2. Use reasonable scraping rates to avoid IP bans\n3. Don't scrape personal data without consent\n4. Store scraped data securely\n5. Comply with GDPR and data protection laws\n",- "isCustomized": false- }- }- },- "masterSkill-1770193849164": {- "skillFolder": "assistant",- "skillsConfig": {- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "python-skill": {- "enabled": true,- "instructions": "# Python Code Execution Tool\n\nExecute Python code for calculations, data processing, and automation tasks.\n\n## How It Works\n\nThis skill provides instructions for the **Python Executor** tool node. Connect the **Python Executor** node to Zeenie's `input-tools` handle to enable Python code execution.\n\n## python_code Tool\n\nExecute Python code and return results.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| code | string | Yes | Python code to execute |\n\n### Available Libraries\n\n| Library | Description |\n|---------|-------------|\n| `math` | Mathematical functions (sqrt, pow, sin, cos, etc.) |\n| `json` | JSON encoding/decoding |\n| `datetime` | Date and time manipulation |\n| `timedelta` | Time duration calculations |\n| `re` | Regular expressions |\n| `random` | Random number generation |\n| `Counter` | Count hashable objects |\n| `defaultdict` | Dictionary with default values |\n\n### Built-in Variables\n\n| Variable | Description |\n|----------|-------------|\n| `input_data` | Data from connected workflow nodes (dict) |\n| `output` | Set this to return a result |\n\n### Output Methods\n\n1. **Set `output` variable**: Returns structured data to the workflow\n2. **Use `print()`**: Captured as console output\n\n### Examples\n\n**Basic calculation:**\n```json\n{\n \"code\": \"result = 25 * 4 + 10\\nprint(f'Result: {result}')\\noutput = result\"\n}\n```\n\n**Calculate tip:**\n```json\n{\n \"code\": \"bill = 85.50\\ntip_percent = 15\\ntip = bill * (tip_percent / 100)\\ntotal = bill + tip\\nprint(f'Tip: ${tip:.2f}')\\nprint(f'Total: ${total:.2f}')\\noutput = {'tip': tip, 'total': total}\"\n}\n```\n\n**Generate random numbers:**\n```json\n{\n \"code\": \"import random\\nnumbers = [random.randint(1, 100) for _ in range(5)]\\nprint(f'Random numbers: {numbers}')\\noutput = numbers\"\n}\n```\n\n**Date calculations:**\n```json\n{\n \"code\": \"from datetime import datetime, timedelta\\ntoday = datetime.now()\\nfuture = today + timedelta(days=30)\\nresult = future.strftime('%Y-%m-%d')\\nprint(f'30 days from now: {result}')\\noutput = result\"\n}\n```\n\n**Process data:**\n```json\n{\n \"code\": \"data = input_data.get('numbers', [1, 2, 3, 4, 5])\\ntotal = sum(data)\\naverage = total / len(data)\\nprint(f'Total: {total}, Average: {average}')\\noutput = {'total': total, 'average': average}\"\n}\n```\n\n**Parse JSON:**\n```json\n{\n \"code\": \"import json\\njson_str = '{\\\"name\\\": \\\"John\\\", \\\"age\\\": 30}'\\ndata = json.loads(json_str)\\nprint(f'Name: {data[\\\"name\\\"]}')\\noutput = data\"\n}\n```\n\n**Count items:**\n```json\n{\n \"code\": \"from collections import Counter\\nitems = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']\\ncounts = dict(Counter(items))\\nprint(f'Counts: {counts}')\\noutput = counts\"\n}\n```\n\n**Text processing:**\n```json\n{\n \"code\": \"import re\\ntext = 'Contact: [email protected] or [email protected]'\\nemails = re.findall(r'\\\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\\.[A-Z|a-z]{2,}\\\\b', text)\\nprint(f'Found emails: {emails}')\\noutput = emails\"\n}\n```\n\n### Response Format\n\n**Success:**\n```json\n{\n \"success\": true,\n \"result\": {\"tip\": 12.825, \"total\": 98.325},\n \"output\": \"Tip: $12.83\\nTotal: $98.33\"\n}\n```\n\n**Error:**\n```json\n{\n \"error\": \"name 'undefined_var' is not defined\"\n}\n```\n\n## Use Cases\n\n| Use Case | Approach |\n|----------|----------|\n| Math calculations | Use `math` library functions |\n| Date/time operations | Use `datetime` and `timedelta` |\n| Data analysis | Use list comprehensions, sum, len |\n| Random generation | Use `random` library |\n| Text parsing | Use `re` regular expressions |\n| JSON manipulation | Use `json.loads()` and `json.dumps()` |\n| Counting | Use `Counter` from collections |\n\n## Guidelines\n\n1. **Always set `output`**: This returns data to the workflow\n2. **Use `print()` for debugging**: Output is captured and returned\n3. **Keep code focused**: One task per execution\n4. **Handle errors**: Use try/except for robust code\n5. **No network access**: Use http-skill for web requests\n6. **No file system access**: Restricted to safe operations\n7. **Timeout**: Default 30 seconds max execution time\n\n## Security Restrictions\n\n- No network/socket operations\n- No file system access outside designated areas\n- No subprocess/shell commands\n- Limited execution time (30 seconds)\n- Sandboxed environment\n\n## Setup Requirements\n\n1. Connect the **Python Executor** node to Zeenie's `input-tools` handle\n2. Python must be installed on the server\n",- "isCustomized": false- },- "javascript-skill": {- "enabled": true,- "instructions": "# JavaScript Code Execution Tool\n\nExecute JavaScript code for calculations, data processing, and JSON manipulation.\n\n## How It Works\n\nThis skill provides instructions for the **JavaScript Executor** tool node. Connect the **JavaScript Executor** node to Zeenie's `input-tools` handle to enable JavaScript code execution.\n\n## javascript_code Tool\n\nExecute JavaScript code and return results.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| code | string | Yes | JavaScript code to execute |\n\n### Available Features\n\n| Feature | Description |\n|---------|-------------|\n| ES6+ syntax | Arrow functions, destructuring, spread operator |\n| `JSON` | JSON.parse() and JSON.stringify() |\n| `Math` | Mathematical operations |\n| `Date` | Date and time manipulation |\n| `Array` methods | map, filter, reduce, sort, etc. |\n| `Object` methods | keys, values, entries, assign |\n| `String` methods | All standard string methods |\n\n### Built-in Variables\n\n| Variable | Description |\n|----------|-------------|\n| `input_data` | Data from connected workflow nodes (object) |\n| `output` | Set this to return a result |\n\n### Output Methods\n\n1. **Set `output` variable**: Returns structured data to the workflow\n2. **Use `console.log()`**: Captured as console output\n\n### Examples\n\n**Basic calculation:**\n```json\n{\n \"code\": \"const result = 25 * 4 + 10;\\nconsole.log(`Result: ${result}`);\\noutput = result;\"\n}\n```\n\n**Array processing:**\n```json\n{\n \"code\": \"const numbers = input_data.numbers || [1, 2, 3, 4, 5];\\nconst total = numbers.reduce((a, b) => a + b, 0);\\nconst average = total / numbers.length;\\nconsole.log(`Total: ${total}, Average: ${average}`);\\noutput = { total, average };\"\n}\n```\n\n**Filter array:**\n```json\n{\n \"code\": \"const numbers = input_data.numbers || [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\\nconst evens = numbers.filter(n => n % 2 === 0);\\nconsole.log(`Even numbers: ${evens}`);\\noutput = evens;\"\n}\n```\n\n**Transform data:**\n```json\n{\n \"code\": \"const users = input_data.users || [{name: 'John', age: 30}, {name: 'Jane', age: 25}];\\nconst names = users.map(u => u.name);\\nconsole.log(`Names: ${names.join(', ')}`);\\noutput = names;\"\n}\n```\n\n**JSON manipulation:**\n```json\n{\n \"code\": \"const data = { name: 'John', age: 30, city: 'NYC' };\\nconst json = JSON.stringify(data, null, 2);\\nconsole.log(json);\\noutput = data;\"\n}\n```\n\n**Object operations:**\n```json\n{\n \"code\": \"const obj = { a: 1, b: 2, c: 3 };\\nconst keys = Object.keys(obj);\\nconst values = Object.values(obj);\\nconst sum = values.reduce((a, b) => a + b, 0);\\nconsole.log(`Sum of values: ${sum}`);\\noutput = { keys, values, sum };\"\n}\n```\n\n**Date operations:**\n```json\n{\n \"code\": \"const now = new Date();\\nconst tomorrow = new Date(now.getTime() + 24 * 60 * 60 * 1000);\\nconst formatted = tomorrow.toISOString().split('T')[0];\\nconsole.log(`Tomorrow: ${formatted}`);\\noutput = formatted;\"\n}\n```\n\n**Sort array:**\n```json\n{\n \"code\": \"const items = input_data.items || ['banana', 'apple', 'cherry'];\\nconst sorted = [...items].sort();\\nconsole.log(`Sorted: ${sorted}`);\\noutput = sorted;\"\n}\n```\n\n**String processing:**\n```json\n{\n \"code\": \"const text = 'Hello World, Hello JavaScript';\\nconst words = text.split(' ');\\nconst unique = [...new Set(words)];\\nconsole.log(`Unique words: ${unique}`);\\noutput = unique;\"\n}\n```\n\n**Destructuring and spread:**\n```json\n{\n \"code\": \"const { name, age } = input_data.user || { name: 'John', age: 30 };\\nconst profile = { name, age, active: true };\\nconst extended = { ...profile, role: 'admin' };\\nconsole.log(JSON.stringify(extended));\\noutput = extended;\"\n}\n```\n\n### Response Format\n\n**Success:**\n```json\n{\n \"success\": true,\n \"result\": { \"total\": 15, \"average\": 3 },\n \"output\": \"Total: 15, Average: 3\"\n}\n```\n\n**Error:**\n```json\n{\n \"error\": \"ReferenceError: undefinedVar is not defined\"\n}\n```\n\n## Use Cases\n\n| Use Case | Approach |\n|----------|----------|\n| Array manipulation | Use map, filter, reduce |\n| JSON processing | Use JSON.parse, JSON.stringify |\n| Object operations | Use Object.keys, values, entries |\n| String processing | Use split, join, replace |\n| Math calculations | Use Math methods |\n| Date operations | Use Date object |\n| Data transformation | Use spread and destructuring |\n\n## Guidelines\n\n1. **Always set `output`**: This returns data to the workflow\n2. **Use `console.log()` for debugging**: Output is captured and returned\n3. **Use ES6+ features**: Arrow functions, destructuring, spread\n4. **Handle undefined**: Use `|| defaultValue` pattern\n5. **Keep code focused**: One task per execution\n6. **No network access**: Use http-skill for web requests\n7. **Timeout**: Default 30 seconds max execution time\n\n## Security Restrictions\n\n- No network/fetch operations\n- No file system access (no require('fs'))\n- No child processes\n- Limited execution time (30 seconds)\n- Sandboxed environment\n\n## Common Patterns\n\n**Default values:**\n```javascript\nconst data = input_data.value || 'default';\n```\n\n**Null-safe access:**\n```javascript\nconst name = input_data?.user?.name || 'Unknown';\n```\n\n**Array to object:**\n```javascript\nconst arr = [{id: 1, name: 'A'}, {id: 2, name: 'B'}];\nconst obj = Object.fromEntries(arr.map(x => [x.id, x.name]));\n```\n\n## Setup Requirements\n\n1. Connect the **JavaScript Executor** node to Zeenie's `input-tools` handle\n2. Node.js must be installed on the server\n",- "isCustomized": false- }- }- },- "console-1770195247780": {- "label": "",- "logMode": "field",- "fieldPath": "{{zeenie.response}}",- "expression": "",- "format": "json"- },- "social_agent-1770213991252": {- "provider": "gemini",- "model": "gemini-3.1-pro-preview",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant"- },- "masterSkill-1770214062703": {- "skillFolder": "social_agent",- "skillsConfig": {- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "twitter-search-skill": {- "enabled": true,- "instructions": "# Twitter Search Tool\n\nSearch for recent tweets on Twitter/X.\n\n## How It Works\n\nThis skill provides instructions for the **Twitter Search** tool node. Connect the **Twitter Search** node to an AI Agent's `input-tools` handle to enable tweet searching.\n\n## twitter_search Tool\n\nSearch for tweets matching a query.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| query | string | Yes | Search query (supports operators) |\n| max_results | integer | No | Number of results (10-100, default: 10) |\n\n### Query Operators\n\nThe X API supports advanced search operators:\n\n| Operator | Example | Description |\n|----------|---------|-------------|\n| keyword | `python` | Tweets containing the word |\n| phrase | `\"machine learning\"` | Exact phrase match |\n| hashtag | `#AI` | Tweets with hashtag |\n| mention | `@username` | Tweets mentioning user |\n| from | `from:elonmusk` | Tweets by specific user |\n| to | `to:username` | Replies to user |\n| -keyword | `-spam` | Exclude keyword |\n| OR | `python OR javascript` | Either term |\n| lang | `lang:en` | Language filter |\n| has:links | `AI has:links` | Tweets with URLs |\n| has:media | `sunset has:media` | Tweets with media |\n| is:retweet | `bitcoin is:retweet` | Only retweets |\n| -is:retweet | `news -is:retweet` | Exclude retweets |\n\n### Examples\n\n**Simple keyword search:**\n```json\n{\n \"query\": \"artificial intelligence\",\n \"max_results\": 20\n}\n```\n\n**Search with hashtag:**\n```json\n{\n \"query\": \"#MachineLearning\",\n \"max_results\": 50\n}\n```\n\n**Search tweets from a user:**\n```json\n{\n \"query\": \"from:OpenAI\",\n \"max_results\": 10\n}\n```\n\n**Complex query:**\n```json\n{\n \"query\": \"AI (startup OR company) -is:retweet lang:en\",\n \"max_results\": 100\n}\n```\n\n**Search with media:**\n```json\n{\n \"query\": \"sunset has:media\",\n \"max_results\": 25\n}\n```\n\n### Response Format\n\n```json\n{\n \"success\": true,\n \"result\": {\n \"tweets\": [\n {\n \"id\": \"1234567890123456789\",\n \"text\": \"Exciting developments in AI...\",\n \"author_id\": \"987654321\",\n \"created_at\": \"2025-02-19T10:30:00Z\"\n }\n ],\n \"count\": 20,\n \"query\": \"#AI\"\n },\n \"execution_time\": 0.82\n}\n```\n\n### Error Response\n\n```json\n{\n \"success\": false,\n \"error\": \"Search query is required\",\n \"execution_time\": 0.01\n}\n```\n\n## Guidelines\n\n1. **Query length**: Keep queries concise for better results\n2. **Max results**: Limited to 100 per request (API constraint)\n3. **Recent tweets only**: X API v2 free tier searches recent tweets (last 7 days)\n4. **Rate limits**: Be mindful of API rate limits when searching repeatedly\n5. **Combine operators**: Use multiple operators for precise filtering\n\n## Common Use Cases\n\n- Monitor brand mentions\n- Track trending topics\n- Find tweets about specific subjects\n- Research competitor activity\n- Gather content for curation\n- Find influencers discussing topics\n\n## Setup Requirements\n\n1. Connect the **Twitter Search** node to an AI Agent's `input-tools` handle\n2. Ensure Twitter is connected (authenticated via OAuth in Credentials Modal)\n3. Your X Developer account must have appropriate API access level\n",- "isCustomized": false- },- "twitter-send-skill": {- "enabled": true,- "instructions": "# Twitter Send Tool\n\nPost and interact with tweets on Twitter/X.\n\n## How It Works\n\nThis skill provides instructions for the **Twitter Send** tool node. Connect the **Twitter Send** node to an AI Agent's `input-tools` handle to enable posting and interactions.\n\n## twitter_send Tool\n\nSend tweets, replies, retweets, likes, and deletions.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| action | string | Yes | Action type: `tweet`, `reply`, `retweet`, `like`, `unlike`, `delete` |\n| text | string | If tweet/reply | Tweet text content (max 280 characters) |\n| tweet_id | string | If retweet/like/unlike/delete | Target tweet ID |\n| reply_to_id | string | If reply | Tweet ID to reply to |\n\n### Actions\n\n| Action | Required Fields | Description |\n|--------|-----------------|-------------|\n| `tweet` | text | Post a new tweet |\n| `reply` | text, reply_to_id | Reply to an existing tweet |\n| `retweet` | tweet_id | Retweet an existing tweet |\n| `like` | tweet_id | Like a tweet |\n| `unlike` | tweet_id | Remove like from a tweet |\n| `delete` | tweet_id | Delete your own tweet |\n\n### Examples\n\n**Post a tweet:**\n```json\n{\n \"action\": \"tweet\",\n \"text\": \"Hello Twitter! This is my first automated tweet.\"\n}\n```\n\n**Reply to a tweet:**\n```json\n{\n \"action\": \"reply\",\n \"text\": \"Thanks for sharing this!\",\n \"reply_to_id\": \"1234567890123456789\"\n}\n```\n\n**Retweet:**\n```json\n{\n \"action\": \"retweet\",\n \"tweet_id\": \"1234567890123456789\"\n}\n```\n\n**Like a tweet:**\n```json\n{\n \"action\": \"like\",\n \"tweet_id\": \"1234567890123456789\"\n}\n```\n\n**Unlike a tweet:**\n```json\n{\n \"action\": \"unlike\",\n \"tweet_id\": \"1234567890123456789\"\n}\n```\n\n**Delete a tweet:**\n```json\n{\n \"action\": \"delete\",\n \"tweet_id\": \"1234567890123456789\"\n}\n```\n\n### Response Format\n\n```json\n{\n \"success\": true,\n \"result\": {\n \"data\": {\n \"id\": \"1234567890123456789\",\n \"text\": \"Hello Twitter!\"\n },\n \"action\": \"tweet_sent\"\n },\n \"execution_time\": 0.45\n}\n```\n\n### Error Response\n\n```json\n{\n \"success\": false,\n \"error\": \"Tweet text is required\",\n \"execution_time\": 0.01\n}\n```\n\n## Guidelines\n\n1. **Character limit**: Tweets are limited to 280 characters\n2. **Tweet IDs**: Use the numeric ID string (e.g., `1234567890123456789`)\n3. **Rate limits**: X API has rate limits - avoid rapid posting\n4. **Content policy**: Follow X's content policies and terms of service\n5. **Threading**: Use reply action with reply_to_id to create threads\n\n## Common Use Cases\n\n- Post automated updates and announcements\n- Reply to mentions or specific tweets\n- Like tweets matching certain criteria\n- Create tweet threads by chaining replies\n- Engage with followers programmatically\n\n## Setup Requirements\n\n1. Connect the **Twitter Send** node to an AI Agent's `input-tools` handle\n2. Ensure Twitter is connected (authenticated via OAuth in Credentials Modal)\n3. Your X Developer account must have appropriate API access level\n",- "isCustomized": false- },- "twitter-user-skill": {- "enabled": true,- "instructions": "# Twitter User Tool\n\nLook up user profiles and social connections on Twitter/X.\n\n## How It Works\n\nThis skill provides instructions for the **Twitter User** tool node. Connect the **Twitter User** node to an AI Agent's `input-tools` handle to enable user lookups.\n\n## twitter_user Tool\n\nRetrieve user information and social connections.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Operation type: `me`, `by_username`, `by_id`, `followers`, `following` |\n| username | string | If by_username | Twitter username (without @) |\n| user_id | string | If by_id/followers/following | Twitter user ID |\n| max_results | integer | No | For followers/following (default: 100, max: 1000) |\n\n### Operations\n\n| Operation | Required Fields | Description |\n|-----------|-----------------|-------------|\n| `me` | none | Get authenticated user's profile |\n| `by_username` | username | Look up user by username |\n| `by_id` | user_id | Look up user by ID |\n| `followers` | user_id (optional) | Get user's followers (defaults to authenticated user) |\n| `following` | user_id (optional) | Get accounts user follows (defaults to authenticated user) |\n\n### Examples\n\n**Get my profile:**\n```json\n{\n \"operation\": \"me\"\n}\n```\n\n**Look up user by username:**\n```json\n{\n \"operation\": \"by_username\",\n \"username\": \"elonmusk\"\n}\n```\n\n**Look up user by ID:**\n```json\n{\n \"operation\": \"by_id\",\n \"user_id\": \"44196397\"\n}\n```\n\n**Get my followers:**\n```json\n{\n \"operation\": \"followers\",\n \"max_results\": 100\n}\n```\n\n**Get accounts I follow:**\n```json\n{\n \"operation\": \"following\",\n \"max_results\": 50\n}\n```\n\n**Get another user's followers:**\n```json\n{\n \"operation\": \"followers\",\n \"user_id\": \"44196397\",\n \"max_results\": 200\n}\n```\n\n### Response Format - Single User\n\n```json\n{\n \"success\": true,\n \"result\": {\n \"user\": {\n \"id\": \"44196397\",\n \"username\": \"elonmusk\",\n \"name\": \"Elon Musk\",\n \"profile_image_url\": \"https://pbs.twimg.com/...\",\n \"verified\": true\n }\n },\n \"execution_time\": 0.35\n}\n```\n\n### Response Format - User List\n\n```json\n{\n \"success\": true,\n \"result\": {\n \"followers\": {\n \"users\": [\n {\n \"id\": \"123456789\",\n \"username\": \"user1\",\n \"name\": \"User One\",\n \"profile_image_url\": \"https://...\",\n \"verified\": false\n }\n ],\n \"count\": 100\n }\n },\n \"execution_time\": 1.2\n}\n```\n\n### Error Response\n\n```json\n{\n \"success\": false,\n \"error\": \"Username is required\",\n \"execution_time\": 0.01\n}\n```\n\n## Guidelines\n\n1. **Usernames**: Provide without the @ symbol (e.g., `elonmusk` not `@elonmusk`)\n2. **User IDs**: Use the numeric ID string\n3. **Rate limits**: Follower/following endpoints have lower rate limits\n4. **Max results**: Limited to 1000 per request for followers/following\n5. **Pagination**: For large accounts, results are paginated (first page returned)\n\n## Common Use Cases\n\n- Get your own profile information\n- Look up profiles of users you interact with\n- Check if users are verified\n- Analyze follower/following relationships\n- Build lists of relevant accounts\n\n## Setup Requirements\n\n1. Connect the **Twitter User** node to an AI Agent's `input-tools` handle\n2. Ensure Twitter is connected (authenticated via OAuth in Credentials Modal)\n3. Your X Developer account must have appropriate API access level\n",- "isCustomized": false- },- "whatsapp-db-skill": {- "enabled": true,- "instructions": "# WhatsApp Database Tool\n\nQuery WhatsApp database for contacts, groups, and message history.\n\n## How It Works\n\nThis skill provides instructions for the **WhatsApp DB** tool node. Connect the **WhatsApp DB** node to Zeenie's `input-tools` handle to enable database queries.\n\n## whatsapp_db Tool\n\nQuery contacts, groups, and chat history.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| operation | string | Yes | Operation type (see below) |\n| chat_type | string | For chat_history | `\"individual\"` or `\"group\"` |\n| phone | string | Varies | Phone number (for chat_history individual, get_contact_info) |\n| group_id | string | Varies | Group JID (for chat_history group, get_group_info) |\n| query | string | No | Search query (for search_groups, list_contacts) |\n| limit | int | No | Max results (varies by operation) |\n| offset | int | No | Pagination offset (for chat_history) |\n| message_filter | string | No | `\"all\"` or `\"text_only\"` (for chat_history) |\n| group_filter | string | No | `\"all\"` or `\"contact\"` (for group chat_history) |\n| sender_phone | string | No | Filter by sender (when group_filter=\"contact\") |\n| phones | string | For check_contacts | Comma-separated phone numbers |\n| participant_limit | int | No | Max participants (for get_group_info, 1-100) |\n\n### Operations\n\n| Operation | Description | Required Fields |\n|-----------|-------------|-----------------|\n| `list_contacts` | List contacts with saved names | query (optional), limit |\n| `get_contact_info` | Get full contact details | phone |\n| `search_groups` | Search groups by name | query, limit |\n| `get_group_info` | Get group details with participants | group_id |\n| `chat_history` | Retrieve message history | chat_type, phone/group_id |\n| `check_contacts` | Check WhatsApp registration | phones |\n\n### Limits\n\n| Operation | Default | Max |\n|-----------|---------|-----|\n| chat_history | 50 | 500 |\n| search_groups | 20 | 50 |\n| list_contacts | 50 | 100 |\n| get_group_info participants | 50 | 100 |\n\n**Important:** Always use small limits and specific queries to avoid context overflow.\n\n## Operation Examples\n\n### list_contacts\n\nFind contacts by name.\n\n```json\n{\n \"operation\": \"list_contacts\",\n \"query\": \"mom\",\n \"limit\": 10\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"list_contacts\",\n \"contacts\": [\n {\"phone\": \"919876543210\", \"name\": \"Mom\", \"jid\": \"[email protected]\"}\n ],\n \"total\": 1\n}\n```\n\n### get_contact_info\n\nGet full contact details for sending/replying.\n\n```json\n{\n \"operation\": \"get_contact_info\",\n \"phone\": \"919876543210\"\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"get_contact_info\",\n \"phone\": \"919876543210\",\n \"name\": \"Mom\",\n \"jid\": \"[email protected]\",\n \"profile_picture\": \"https://...\"\n}\n```\n\n### search_groups\n\nSearch groups by name.\n\n```json\n{\n \"operation\": \"search_groups\",\n \"query\": \"family\",\n \"limit\": 10\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"search_groups\",\n \"groups\": [\n {\"group_id\": \"[email protected]\", \"name\": \"Family Group\", \"participant_count\": 5}\n ],\n \"total\": 1\n}\n```\n\n### get_group_info\n\nGet group details with participant list.\n\n```json\n{\n \"operation\": \"get_group_info\",\n \"group_id\": \"[email protected]\",\n \"participant_limit\": 20\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"get_group_info\",\n \"name\": \"Family Group\",\n \"jid\": \"[email protected]\",\n \"participants\": [\n {\"phone\": \"919876543210\", \"name\": \"Mom\", \"is_admin\": true},\n {\"phone\": \"919876543211\", \"name\": \"Dad\", \"is_admin\": false}\n ],\n \"total_participants\": 5\n}\n```\n\n### chat_history (Individual)\n\nGet messages from an individual chat.\n\n```json\n{\n \"operation\": \"chat_history\",\n \"chat_type\": \"individual\",\n \"phone\": \"919876543210\",\n \"limit\": 20\n}\n```\n\n### chat_history (Group)\n\nGet messages from a group chat.\n\n```json\n{\n \"operation\": \"chat_history\",\n \"chat_type\": \"group\",\n \"group_id\": \"[email protected]\",\n \"message_filter\": \"text_only\",\n \"limit\": 50\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"chat_history\",\n \"messages\": [\n {\n \"index\": 1,\n \"message_id\": \"ABC123\",\n \"sender\": \"[email protected]\",\n \"sender_name\": \"Mom\",\n \"text\": \"Hello!\",\n \"timestamp\": \"2025-01-30T12:00:00\",\n \"is_from_me\": false\n }\n ],\n \"total\": 50,\n \"has_more\": true\n}\n```\n\n### check_contacts\n\nCheck if phone numbers have WhatsApp.\n\n```json\n{\n \"operation\": \"check_contacts\",\n \"phones\": \"1234567890,0987654321\"\n}\n```\n\n**Response:**\n```json\n{\n \"success\": true,\n \"operation\": \"check_contacts\",\n \"results\": [\n {\"phone\": \"1234567890\", \"registered\": true, \"jid\": \"[email protected]\"},\n {\"phone\": \"0987654321\", \"registered\": false}\n ]\n}\n```\n\n## Common Workflows\n\n### Find and message someone by name\n\n1. Use `list_contacts` with query to find the person\n2. Get their phone number from the result\n3. Use `whatsapp_send` tool with the phone number\n\n### Get recent messages from a contact\n\n1. Use `chat_history` with chat_type=\"individual\"\n2. Set appropriate limit for desired history depth\n\n### Find and message a group\n\n1. Use `search_groups` to find the group by name\n2. Get the group_id from the result\n3. Use `whatsapp_send` tool with recipient_type=\"group\"\n\n### See who's in a group\n\n1. Use `get_group_info` with the group_id\n2. Set participant_limit to control output size\n\n## Guidelines\n\n1. **Phone numbers**: Always use without + prefix, just digits\n2. **Group IDs**: JID format ending in `@g.us`\n3. **Limits**: Use small limits to avoid context overflow\n4. **Queries**: Be specific to narrow results\n5. **Pagination**: Use offset to page through chat_history\n\n## Error Responses\n\n```json\n{\n \"error\": \"Phone number is required for chat_type='individual'\"\n}\n```\n\n```json\n{\n \"error\": \"group_id is required for get_group_info\"\n}\n```\n\n## Setup Requirements\n\n1. Connect the **WhatsApp DB** node to Zeenie's `input-tools` handle\n2. Ensure WhatsApp is connected (green status indicator in Credentials)\n",- "isCustomized": false- },- "whatsapp-send-skill": {- "enabled": true,- "instructions": "# WhatsApp Send Tool\n\nSend messages to WhatsApp contacts or groups.\n\n## How It Works\n\nThis skill provides instructions for the **WhatsApp Send** tool node. Connect the **WhatsApp Send** node to Zeenie's `input-tools` handle to enable message sending.\n\n## whatsapp_send Tool\n\nSend messages to individual contacts or groups.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| recipient_type | string | Yes | `\"phone\"` for individual or `\"group\"` for group chat |\n| phone | string | If phone | Phone number without + prefix (e.g., `1234567890`) |\n| group_id | string | If group | Group JID (e.g., `[email protected]`) |\n| message_type | string | Yes | Message type (see below) |\n| message | string | If text | Text message content |\n| media_url | string | If media | URL for image/video/audio/document/sticker |\n| caption | string | No | Caption for media messages |\n| latitude | float | If location | Latitude coordinate |\n| longitude | float | If location | Longitude coordinate |\n| location_name | string | No | Display name for location |\n| address | string | No | Address text for location |\n| contact_name | string | If contact | Contact display name |\n| vcard | string | If contact | vCard 3.0 format string |\n\n### Message Types\n\n| Type | Required Fields | Description |\n|------|-----------------|-------------|\n| `text` | message | Plain text message |\n| `image` | media_url | Image file (JPG, PNG, GIF) |\n| `video` | media_url | Video file (MP4) |\n| `audio` | media_url | Audio file (MP3, OGG, WAV) |\n| `document` | media_url | Any file type |\n| `sticker` | media_url | Sticker image (WebP) |\n| `location` | latitude, longitude | GPS coordinates |\n| `contact` | contact_name, vcard | Contact card |\n\n### Examples\n\n**Send text message to contact:**\n```json\n{\n \"recipient_type\": \"phone\",\n \"phone\": \"1234567890\",\n \"message_type\": \"text\",\n \"message\": \"Hello! How are you?\"\n}\n```\n\n**Send image with caption:**\n```json\n{\n \"recipient_type\": \"phone\",\n \"phone\": \"1234567890\",\n \"message_type\": \"image\",\n \"media_url\": \"https://example.com/photo.jpg\",\n \"caption\": \"Check out this photo!\"\n}\n```\n\n**Send to group:**\n```json\n{\n \"recipient_type\": \"group\",\n \"group_id\": \"[email protected]\",\n \"message_type\": \"text\",\n \"message\": \"Hello everyone!\"\n}\n```\n\n**Send video:**\n```json\n{\n \"recipient_type\": \"phone\",\n \"phone\": \"1234567890\",\n \"message_type\": \"video\",\n \"media_url\": \"https://example.com/video.mp4\",\n \"caption\": \"Check this video\"\n}\n```\n\n**Send document:**\n```json\n{\n \"recipient_type\": \"phone\",\n \"phone\": \"1234567890\",\n \"message_type\": \"document\",\n \"media_url\": \"https://example.com/report.pdf\",\n \"caption\": \"Here's the report\"\n}\n```\n\n**Send location:**\n```json\n{\n \"recipient_type\": \"phone\",\n \"phone\": \"1234567890\",\n \"message_type\": \"location\",\n \"latitude\": 37.7749,\n \"longitude\": -122.4194,\n \"location_name\": \"San Francisco\",\n \"address\": \"San Francisco, CA, USA\"\n}\n```\n\n**Send contact card:**\n```json\n{\n \"recipient_type\": \"phone\",\n \"phone\": \"1234567890\",\n \"message_type\": \"contact\",\n \"contact_name\": \"John Doe\",\n \"vcard\": \"BEGIN:VCARD\\nVERSION:3.0\\nFN:John Doe\\nTEL:+1234567890\\nEND:VCARD\"\n}\n```\n\n### Response Format\n\n```json\n{\n \"success\": true,\n \"recipient\": \"1234567890\",\n \"recipient_type\": \"phone\",\n \"message_type\": \"text\",\n \"details\": {\n \"status\": \"sent\",\n \"preview\": \"Hello! How are you?\",\n \"timestamp\": \"2025-01-30T12:00:00\"\n }\n}\n```\n\n### Error Response\n\n```json\n{\n \"error\": \"Phone number is required for recipient_type='phone'\"\n}\n```\n\n## Guidelines\n\n1. **Phone numbers**: Always use without + prefix, just digits (e.g., `919876543210`)\n2. **Group IDs**: Use JID format ending in `@g.us` (e.g., `[email protected]`)\n3. **Media URLs**: Must be publicly accessible URLs (https://)\n4. **vCard format**: Use vCard 3.0 specification for contact cards\n5. **Message length**: Text messages can be up to 4096 characters\n6. **Media size**: Check WhatsApp limits for media file sizes\n\n## Common Use Cases\n\n- Send automated notifications to contacts\n- Forward messages to groups\n- Share media files\n- Send location information\n- Share contact information\n\n## Setup Requirements\n\n1. Connect the **WhatsApp Send** node to Zeenie's `input-tools` handle\n2. Ensure WhatsApp is connected (green status indicator in Credentials)\n3. The recipient must have WhatsApp installed\n",- "isCustomized": false- }- }- },- "travel_agent-1770223640970": {- "provider": "gemini",- "model": "gemini-3.1-pro-preview",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant"- },- "masterSkill-1770223871841": {- "skillFolder": "travel_agent",- "skillsConfig": {- "assistant-personality": {- "enabled": true,- "instructions": "# Assistant Personality\n\nYou are a helpful, harmless, and honest AI assistant. Your goal is to assist users with their requests while being truthful and avoiding harmful content.\n\n## Core Principles\n\n1. **Helpfulness**: Provide clear, accurate, and useful information\n2. **Honesty**: Be truthful about your capabilities and limitations\n3. **Safety**: Avoid generating harmful, illegal, or unethical content\n\n## Communication Style\n\n- Be concise but thorough\n- Use clear, simple language\n- Break down complex topics into understandable parts\n- Ask clarifying questions when needed\n- Admit when you don't know something\n\n## Response Guidelines\n\nWhen responding to users:\n1. Understand the intent behind their question\n2. Provide the most helpful response possible\n3. Include relevant context or caveats\n4. Suggest follow-up questions if appropriate\n\n## Examples\n\nUser: \"What's the weather like?\"\nResponse: I don't have access to real-time weather data. However, I can help you find weather information if you tell me your location, or you can use a weather service like weather.com.\n\nUser: \"Help me write an email\"\nResponse: I'd be happy to help you write an email. Could you tell me:\n- Who is the recipient?\n- What is the purpose of the email?\n- What tone would you like (formal, casual, etc.)?\n",- "isCustomized": false- },- "compaction-skill": {- "enabled": true,- "instructions": "# Memory Compaction Skill\n\nYou have the ability to compact conversation memory when it grows too large. Compaction transforms verbose conversation history into a structured summary that preserves essential context while reducing token usage.\n\n## When to Compact\n\nCompact memory when:\n- The system indicates token threshold is approaching\n- Conversation history becomes repetitive or verbose\n- You need to preserve important context but reduce size\n- Starting a new phase of work after completing a major task\n\n## Compaction Summary Structure\n\nWhen compacting, create a summary with these 5 sections:\n\n### 1. Task Overview\nWhat the user is trying to accomplish. Include:\n- Primary goal or objective\n- Key constraints or requirements\n- Scope of the work\n\n### 2. Current State\nWhat's been completed and what's in progress:\n- Completed tasks and their outcomes\n- Work currently in flight\n- Pending decisions or blockers\n\n### 3. Important Discoveries\nKey findings, decisions, or problems encountered:\n- Technical discoveries or insights\n- Decisions made and their rationale\n- Problems encountered and solutions applied\n- User preferences learned\n\n### 4. Next Steps\nWhat needs to happen next:\n- Immediate actions required\n- Planned approach for remaining work\n- Dependencies or prerequisites\n\n### 5. Context to Preserve\nCritical details that must be retained:\n- Specific values, IDs, or references\n- User preferences or constraints\n- Technical details needed for continuity\n- Any warnings or caveats\n\n## Compaction Format\n\nOutput the compacted summary in this format:\n\n```markdown\n# Conversation Summary (Compacted)\n*Generated: [ISO timestamp]*\n\n## Task Overview\n[1-3 sentences describing the goal]\n\n## Current State\n- [Completed item 1]\n- [Completed item 2]\n- [In progress: description]\n\n## Important Discoveries\n- [Discovery 1 with context]\n- [Decision made: rationale]\n- [Problem solved: approach]\n\n## Next Steps\n1. [Next action]\n2. [Following action]\n\n## Context to Preserve\n- [Critical detail 1]\n- [Critical detail 2]\n```\n\n## Best Practices\n\n1. **Be Concise**: Each section should be brief but complete\n2. **Preserve Specifics**: Keep exact values, names, and references\n3. **Capture Decisions**: Record WHY decisions were made, not just WHAT\n4. **Include Failures**: Document what didn't work to avoid repetition\n5. **Maintain Continuity**: Summary should allow seamless continuation\n\n## What NOT to Include\n\n- Verbose back-and-forth dialogue\n- Redundant information\n- Superseded decisions (only keep final decisions)\n- Exploratory tangents that didn't lead anywhere\n- Standard pleasantries or acknowledgments\n\n## Example Compaction\n\n**Before** (verbose history):\n```\nHuman: Can you help me debug this Python function?\nAI: Of course! Please share the function.\nHuman: Here's the function: def calculate(x): return x * 2\nAI: I see the function. What issue are you experiencing?\nHuman: It returns None sometimes\nAI: That's interesting. Can you show me an example input?\nHuman: calculate(\"5\") returns None\nAI: Ah, I see the issue! When you pass a string...\n[continues for 50+ messages]\n```\n\n**After** (compacted):\n```markdown\n# Conversation Summary (Compacted)\n*Generated: 2025-02-13T10:30:00Z*\n\n## Task Overview\nDebug Python function `calculate(x)` that returns None for some inputs.\n\n## Current State\n- Identified root cause: string inputs cause implicit None return\n- Implemented fix with type checking and conversion\n- Tests passing for int, float, and string inputs\n\n## Important Discoveries\n- Original function had no type validation\n- String multiplication in Python doesn't raise error but behaves unexpectedly\n- User prefers explicit error messages over silent failures\n\n## Next Steps\n1. Add input validation for edge cases (None, empty string)\n2. Write unit tests for the fixed function\n\n## Context to Preserve\n- Function location: `utils/math_helpers.py:45`\n- User wants to maintain backward compatibility\n- Prefer raising ValueError over returning None\n```\n\n## Integration with Memory System\n\nWhen compaction is triggered:\n1. The compacted summary replaces the current memory content\n2. New conversation messages are appended after the summary\n3. The summary header indicates when compaction occurred\n\nThis allows conversation to continue naturally while maintaining reduced token usage.\n",- "isCustomized": false- },- "humanify-skill": {- "enabled": true,- "instructions": "# Humanify Output Skill\n\nFormat your responses for human readability. Output clean, pretty text that's easy to scan and understand - not raw markdown syntax or code-heavy formatting.\n\n## Core Principles\n\n1. **Plain Language First**: Write naturally, as if speaking to someone\n2. **Visual Clarity**: Use spacing, indentation, and structure for scannability\n3. **No Raw Syntax**: Avoid showing markdown symbols, JSON, or code unless specifically requested\n4. **Progressive Detail**: Lead with key information, details follow\n\n## Formatting Guidelines\n\n### Instead of Markdown Headers\n```\nBad: ## Section Title\nGood: SECTION TITLE\n -------------\n```\n\n### Instead of Bullet Lists with Symbols\n```\nBad: - Item one\n - Item two\n\nGood: Item one\n Item two\n\n or: * Item one\n * Item two\n```\n\n### Instead of Code Blocks for Data\n```\nBad: ```json\n {\"name\": \"John\", \"age\": 30}\n ```\n\nGood: Name: John\n Age: 30\n```\n\n### Instead of Tables with Pipes\n```\nBad: | Name | Value |\n |------|-------|\n | Foo | 123 |\n\nGood: Name Value\n ---- -----\n Foo 123\n```\n\n### Instead of Raw URLs\n```\nBad: Check https://example.com/very/long/path/to/resource\n\nGood: Check the resource page (link available)\n or: Resource: example.com\n```\n\n## Response Patterns\n\n### For Status Updates\n```\nStatus: Complete\nTime: 2.3 seconds\nResult: Successfully processed 15 items\n\nDetails:\n Processed: 15\n Skipped: 2\n Errors: 0\n```\n\n### For Lists of Items\n```\nFound 3 matching files:\n\n 1. config.json\n Location: /app/settings\n Modified: Today\n\n 2. config.backup.json\n Location: /app/backups\n Modified: Yesterday\n\n 3. config.old.json\n Location: /archive\n Modified: Last week\n```\n\n### For Explanations\n```\nThe function calculates the total by:\n\n First, it gathers all input values\n Then, it filters out any invalid entries\n Finally, it sums the remaining numbers\n\nNote: Empty inputs are treated as zero.\n```\n\n### For Errors or Warnings\n```\nCould not complete the request.\n\nReason: The file was not found at the specified location.\n\nSuggestions:\n Check if the file path is correct\n Verify the file exists\n Ensure you have read permissions\n```\n\n### For Confirmations\n```\nDone! Created new user account.\n\n Username: jsmith\n Email: [email protected]\n Role: Editor\n\nNext: The user will receive a welcome email shortly.\n```\n\n## When to Use Each Style\n\n### Use Pretty Formatting When:\n- Showing results or status\n- Explaining concepts\n- Listing options or items\n- Providing instructions\n- Displaying data summaries\n\n### Keep Technical Formatting When:\n- User explicitly requests code/markdown\n- Showing code that needs to be copied\n- Displaying configuration files\n- Technical documentation\n- API responses that need exact format\n\n## Typography Tips\n\n### Visual Separators\n```\nSection breaks: ---------------\nLight dividers: . . . . . . . .\nBox drawing: +-------------+\n | Content |\n +-------------+\n```\n\n### Emphasis Without Markdown\n```\nInstead of **bold**: Use CAPS or spacing\nInstead of *italic*: Use quotes or context\nInstead of `code`: Use clear naming\n```\n\n### Spacing for Clarity\n```\nGroup related items with spacing:\n\n Primary Actions\n Save changes\n Submit form\n\n Secondary Actions\n Cancel\n Reset\n```\n\n## Examples\n\n### Bad (Raw Markdown)\n```\n### Results\n- **Found**: 5 files\n- **Size**: 2.3MB\n- **Status**: `complete`\n\nSee [documentation](https://docs.example.com) for more info.\n```\n\n### Good (Humanified)\n```\nRESULTS\n-------\nFound: 5 files\nSize: 2.3 MB\nStatus: Complete\n\nSee the documentation for more details.\n```\n\n## Remember\n\nThe goal is communication, not formatting. Choose the clearest way to convey information to a human reader. When in doubt, write it as you would explain it to a colleague standing next to you.\n",- "isCustomized": false- },- "memory-skill": {- "enabled": true,- "instructions": "# Memory Management Skill\n\nThis skill enables you to manage conversation memory using the SimpleMemory node's markdown-based storage system.\n\n## Memory Architecture\n\n### Short-Term Memory (Markdown)\n- Visible and editable in the SimpleMemory node's UI\n- Stored as markdown with timestamped entries\n- Window-based: keeps last N message pairs (configurable)\n- Format: `### **Human** (timestamp)` and `### **Assistant** (timestamp)`\n\n### Long-Term Memory (Vector DB)\n- Automatically archives messages that exceed the window\n- Semantic search for relevant past conversations\n- Enabled via `longTermEnabled` in SimpleMemory node\n\n## Capabilities\n\n1. **View History**: See recent conversation in markdown format\n2. **Save Notes**: Add explicit notes/memories to the conversation\n3. **Search Memory**: Find relevant past conversations semantically\n4. **Clear Memory**: Reset conversation history\n\n## When to Use\n\n**Save information when:**\n- User says \"remember this\" or \"don't forget\"\n- Important context is shared for future use\n- User wants to note something specific\n\n**Recall information when:**\n- User asks \"do you remember...\"\n- Context from earlier is needed\n- User references previous discussions\n\n**View history when:**\n- User wants to see conversation log\n- Debugging or reviewing past exchanges\n\n## Tool Reference\n\n### memory-save\nAdd a note or memory entry to the conversation history.\n\nParameters:\n- `content` (required): Information to remember\n- `role` (optional): \"note\" (default) or \"context\"\n\nExample:\n```json\n{\n \"content\": \"User's favorite color is blue\",\n \"role\": \"note\"\n}\n```\n\n### memory-get\nGet recent conversation history or search for specific content.\n\nParameters:\n- `count` (optional): Number of recent messages (default: 10)\n- `search` (optional): Search term to find specific memories\n\nExample - Recent history:\n```json\n{\n \"count\": 5\n}\n```\n\nExample - Search:\n```json\n{\n \"search\": \"favorite color\"\n}\n```\n\n### memory-clear\nClear conversation history.\n\nParameters:\n- `confirm` (required): Must be true to clear\n\nExample:\n```json\n{\n \"confirm\": true\n}\n```\n\n### memory-view\nView the current conversation history in markdown format.\n\nParameters: None\n\nReturns the full markdown content of the conversation history.\n\n### memory-search\nSemantic search in long-term memory (if enabled).\n\nParameters:\n- `query` (required): Search query\n- `count` (optional): Number of results (default: 3)\n\nExample:\n```json\n{\n \"query\": \"what did we discuss about the project\",\n \"count\": 5\n}\n```\n\n## Markdown Format\n\nThe conversation history uses this format:\n\n```markdown\n# Conversation History\n\n### **Human** (2025-01-30 10:15:32)\nHello, how are you?\n\n### **Assistant** (2025-01-30 10:15:35)\nI'm doing well! How can I help you today?\n\n### **Note** (2025-01-30 10:16:00)\nUser prefers formal language.\n```\n\n## Integration with SimpleMemory Node\n\nWhen connected to a Zeenie:\n1. Conversation is automatically logged to markdown\n2. Window size limits short-term memory\n3. Overflow archives to vector DB (if long-term enabled)\n4. You can view/edit the markdown in the node's parameter panel\n\n## Best Practices\n\n1. Use memory-save for explicit user requests to remember\n2. Use memory-search for semantic recall of past discussions\n3. Don't save sensitive information without user consent\n4. The markdown is editable - users can manually curate their history\n",- "isCustomized": false- },- "geocoding-skill": {- "enabled": true,- "instructions": "# Geocoding Tool\n\nConvert addresses to GPS coordinates or coordinates to addresses using Google Maps Geocoding API.\n\n## How It Works\n\nThis skill provides instructions for the **Add Locations** (gmaps_locations) tool node. Connect the **Add Locations** node to Zeenie's `input-tools` handle to enable geocoding operations.\n\n## add_locations Tool\n\nGeocode addresses or reverse geocode coordinates.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| service_type | string | Yes | `\"geocode\"` (address to coordinates) or `\"reverse_geocode\"` (coordinates to address) |\n| address | string | If geocode | Address to convert to coordinates |\n| lat | float | If reverse_geocode | Latitude coordinate |\n| lng | float | If reverse_geocode | Longitude coordinate |\n\n### Operations\n\n| Service Type | Input | Output |\n|--------------|-------|--------|\n| `geocode` | Address string | Coordinates (lat, lng) |\n| `reverse_geocode` | Coordinates (lat, lng) | Formatted address |\n\n### Examples\n\n**Geocode an address:**\n```json\n{\n \"service_type\": \"geocode\",\n \"address\": \"1600 Amphitheatre Parkway, Mountain View, CA\"\n}\n```\n\n**Geocode a landmark:**\n```json\n{\n \"service_type\": \"geocode\",\n \"address\": \"Eiffel Tower, Paris\"\n}\n```\n\n**Geocode a city:**\n```json\n{\n \"service_type\": \"geocode\",\n \"address\": \"New York City, USA\"\n}\n```\n\n**Reverse geocode (coordinates to address):**\n```json\n{\n \"service_type\": \"reverse_geocode\",\n \"lat\": 48.8584,\n \"lng\": 2.2945\n}\n```\n\n### Response Format\n\n**Geocode response:**\n```json\n{\n \"success\": true,\n \"service_type\": \"geocoding\",\n \"input\": {\"address\": \"Eiffel Tower, Paris\"},\n \"results\": [\n {\n \"formatted_address\": \"Champ de Mars, 5 Av. Anatole France, 75007 Paris, France\",\n \"geometry\": {\n \"location\": {\"lat\": 48.8583701, \"lng\": 2.2944813}\n },\n \"address_components\": [\n {\"long_name\": \"5\", \"short_name\": \"5\", \"types\": [\"street_number\"]},\n {\"long_name\": \"Avenue Anatole France\", \"short_name\": \"Av. Anatole France\", \"types\": [\"route\"]},\n {\"long_name\": \"Paris\", \"short_name\": \"Paris\", \"types\": [\"locality\"]}\n ]\n }\n ],\n \"status\": \"OK\"\n}\n```\n\n**Reverse geocode response:**\n```json\n{\n \"success\": true,\n \"service_type\": \"reverse_geocoding\",\n \"input\": {\"lat\": 48.8584, \"lng\": 2.2945},\n \"results\": [\n {\n \"formatted_address\": \"Champ de Mars, 5 Av. Anatole France, 75007 Paris, France\",\n \"geometry\": {\n \"location\": {\"lat\": 48.8583701, \"lng\": 2.2944813}\n },\n \"address_components\": [...]\n }\n ],\n \"status\": \"OK\"\n}\n```\n\n### Error Response\n\n```json\n{\n \"error\": \"address is required for geocoding\"\n}\n```\n\n```json\n{\n \"error\": \"Geocoding failed: ZERO_RESULTS\"\n}\n```\n\n## Use Cases\n\n| Use Case | Service Type | Description |\n|----------|--------------|-------------|\n| Find location | geocode | Get coordinates for an address |\n| Validate address | geocode | Get standardized address format |\n| Get address | reverse_geocode | Find address from GPS coordinates |\n| Location lookup | geocode | Search for landmarks, POIs |\n\n## Common Workflows\n\n### Get coordinates for sending location via WhatsApp\n\n1. Use `geocode` to convert address to coordinates\n2. Extract `lat` and `lng` from response\n3. Use `whatsapp_send` with message_type=\"location\"\n\n### Identify a GPS location\n\n1. Use `reverse_geocode` with lat/lng coordinates\n2. Get formatted address from response\n\n### Search for nearby places\n\n1. Use `geocode` to get coordinates from address\n2. Use `nearby_places` tool with those coordinates\n\n## Address Format Guidelines\n\n**Good address formats:**\n- `\"123 Main Street, New York, NY 10001\"`\n- `\"Eiffel Tower, Paris, France\"`\n- `\"Times Square, NYC\"`\n- `\"Tokyo Station, Japan\"`\n\n**Tips:**\n- Include city and country for better accuracy\n- Landmarks and POIs work well\n- Postal codes improve precision\n- Use local language or English\n\n## Coordinate Guidelines\n\n- Latitude range: -90 to 90\n- Longitude range: -180 to 180\n- More decimal places = higher precision\n- Standard precision: 6 decimal places\n\n## Setup Requirements\n\n1. Connect the **Add Locations** (gmaps_locations) node to Zeenie's `input-tools` handle\n2. Google Maps API key must be configured in Credentials\n3. Geocoding API must be enabled in Google Cloud Console\n",- "isCustomized": false- },- "nearby-places-skill": {- "enabled": true,- "instructions": "# Nearby Places Tool\n\nSearch for places near a location using Google Places API.\n\n## How It Works\n\nThis skill provides instructions for the **Show Nearby Places** (gmaps_nearby_places) tool node. Connect the **Show Nearby Places** node to Zeenie's `input-tools` handle to enable place search.\n\n## show_nearby_places Tool\n\nSearch for places near GPS coordinates.\n\n### Schema Fields\n\n| Field | Type | Required | Description |\n|-------|------|----------|-------------|\n| lat | float | Yes | Center latitude for search |\n| lng | float | Yes | Center longitude for search |\n| radius | int | No | Search radius in meters (default: 500, max: 50000) |\n| type | string | No | Place type to search for (default: \"restaurant\") |\n| keyword | string | No | Keyword to filter results |\n\n### Place Types\n\n**Food & Drink:**\n- `restaurant` - Restaurants\n- `cafe` - Coffee shops\n- `bar` - Bars and pubs\n- `bakery` - Bakeries\n- `meal_takeaway` - Takeout restaurants\n\n**Shopping:**\n- `store` - General stores\n- `supermarket` - Grocery stores\n- `shopping_mall` - Shopping centers\n- `clothing_store` - Clothing shops\n- `convenience_store` - Convenience stores\n\n**Services:**\n- `bank` - Banks\n- `atm` - ATMs\n- `gas_station` - Gas/petrol stations\n- `pharmacy` - Pharmacies\n- `post_office` - Post offices\n\n**Health:**\n- `hospital` - Hospitals\n- `doctor` - Doctor's offices\n- `dentist` - Dental clinics\n\n**Transport:**\n- `bus_station` - Bus stations\n- `train_station` - Train stations\n- `airport` - Airports\n- `taxi_stand` - Taxi stands\n- `parking` - Parking lots\n\n**Entertainment:**\n- `movie_theater` - Cinemas\n- `gym` - Fitness centers\n- `park` - Parks\n- `museum` - Museums\n- `zoo` - Zoos\n\n**Accommodation:**\n- `hotel` - Hotels\n- `lodging` - All lodging types\n\n### Examples\n\n**Find nearby restaurants:**\n```json\n{\n \"lat\": 40.7484,\n \"lng\": -73.9857,\n \"radius\": 500,\n \"type\": \"restaurant\"\n}\n```\n\n**Find coffee shops:**\n```json\n{\n \"lat\": 37.7749,\n \"lng\": -122.4194,\n \"type\": \"cafe\",\n \"radius\": 1000\n}\n```\n\n**Find specific chain:**\n```json\n{\n \"lat\": 37.7749,\n \"lng\": -122.4194,\n \"type\": \"cafe\",\n \"keyword\": \"starbucks\"\n}\n```\n\n**Find gas stations:**\n```json\n{\n \"lat\": 34.0522,\n \"lng\": -118.2437,\n \"type\": \"gas_station\",\n \"radius\": 2000\n}\n```\n\n**Find hotels:**\n```json\n{\n \"lat\": 51.5074,\n \"lng\": -0.1278,\n \"type\": \"hotel\",\n \"radius\": 1000\n}\n```\n\n### Response Format\n\n```json\n{\n \"success\": true,\n \"type\": \"restaurant\",\n \"search_parameters\": {\n \"location\": {\"lat\": 40.7484, \"lng\": -73.9857},\n \"radius\": 500,\n \"type\": \"restaurant\"\n },\n \"results\": [\n {\n \"name\": \"Example Restaurant\",\n \"vicinity\": \"123 Main St, New York\",\n \"rating\": 4.5,\n \"user_ratings_total\": 150,\n \"price_level\": 2,\n \"geometry\": {\n \"location\": {\"lat\": 40.7485, \"lng\": -73.9860}\n },\n \"types\": [\"restaurant\", \"food\", \"establishment\"],\n \"opening_hours\": {\"open_now\": true}\n }\n ],\n \"total_results\": 10,\n \"status\": \"OK\"\n}\n```\n\n### Response Fields\n\n| Field | Description |\n|-------|-------------|\n| name | Place name |\n| vicinity | Address or location description |\n| rating | Average rating (1-5) |\n| user_ratings_total | Number of reviews |\n| price_level | Price level (0-4, 0=free, 4=very expensive) |\n| geometry.location | Place coordinates |\n| types | Place type categories |\n| opening_hours.open_now | Whether currently open |\n\n### Error Response\n\n```json\n{\n \"error\": \"lat and lng are required for nearby places search\"\n}\n```\n\n## Price Level Guide\n\n| Level | Meaning |\n|-------|---------|\n| 0 | Free |\n| 1 | Inexpensive ($) |\n| 2 | Moderate ($$) |\n| 3 | Expensive ($$$) |\n| 4 | Very Expensive ($$$$) |\n\n## Common Workflows\n\n### Find places near an address\n\n1. Use `geocoding` tool to convert address to coordinates\n2. Use `nearby_places` with the lat/lng from step 1\n\n### Find best-rated places\n\n1. Search with appropriate type and radius\n2. Sort results by rating in response\n3. Filter by minimum rating threshold\n\n### Find open places now\n\n1. Search with desired type\n2. Check `opening_hours.open_now` in results\n\n## Radius Guidelines\n\n| Radius | Use Case |\n|--------|----------|\n| 100-500m | Walking distance |\n| 500-1000m | Short walk |\n| 1000-2000m | 5-10 min walk |\n| 2000-5000m | Driving distance |\n| 5000-50000m | City-wide search |\n\n## Tips\n\n1. **Use specific types**: \"cafe\" not \"coffee\"\n2. **Add keywords**: Filter by chain name or cuisine\n3. **Adjust radius**: Start small, expand if needed\n4. **Check ratings**: Higher ratings usually mean better quality\n5. **Verify open_now**: Important for time-sensitive searches\n\n## Setup Requirements\n\n1. Connect the **Show Nearby Places** (gmaps_nearby_places) node to Zeenie's `input-tools` handle\n2. Google Maps API key must be configured in Credentials\n3. Places API must be enabled in Google Cloud Console\n",- "isCustomized": false- }- }- },- "simpleMemory-1770973684811": {- "sessionId": "",- "windowSize": 100,- "longTermEnabled": false,- "retrievalCount": 3- },- "simpleMemory-1770973759469": {- "sessionId": "",- "windowSize": 100,- "longTermEnabled": false,- "retrievalCount": 3- },- "productivity_agent-1771834433838": {- "provider": "gemini",- "model": "gemini-3.1-pro-preview",- "prompt": "{{ $json.chatInput }}",- "systemMessage": "You are a helpful assistant"- },- "gmail-1772074604463": {- "operation": "send",- "account_mode": "owner",- "customer_id": "",- "to": "",- "cc": "",- "bcc": "",- "subject": "",- "body_type": "text",- "body": "",- "query": "",- "max_results": 10,- "include_body": false,- "message_id": "",- "format": "full",- "label": "Gmail"- },- "calendar-1772074605773": {- "operation": "create",- "account_mode": "owner",- "customer_id": "",- "calendar_id": "primary",- "title": "",- "start_time": "",- "end_time": "",- "description": "",- "location": "",- "attendees": "",- "timezone": "UTC",- "reminder_minutes": 30,- "start_date": "today",- "end_date": "today+7d",- "max_results": 10,- "single_events": true,- "order_by": "startTime",- "event_id": "",- "update_title": "",- "update_start_time": "",- "update_end_time": "",- "update_description": "",- "update_location": "",- "send_updates": "all",- "label": "Calendar"- },- "drive-1772074607205": {- "operation": "list",- "account_mode": "owner",- "customer_id": "",- "file_url": "",- "file_content": "",- "filename": "",- "mime_type": "",- "folder_id": "",- "file_description": "",- "file_id": "",- "output_format": "base64",- "query": "",- "file_types": "all",- "max_results": 20,- "order_by": "modifiedTime desc",- "email": "",- "role": "reader",- "send_notification": true,- "message": "",- "label": "Drive"- },- "sheets-1772074608160": {- "operation": "read",- "account_mode": "owner",- "customer_id": "",- "spreadsheet_id": "",- "range": "",- "value_render_option": "FORMATTED_VALUE",- "major_dimension": "ROWS",- "values": "",- "value_input_option": "USER_ENTERED",- "insert_data_option": "INSERT_ROWS",- "label": "Sheets"- },- "tasks-1772074609131": {- "operation": "create",- "account_mode": "owner",- "customer_id": "",- "tasklist_id": "@default",- "title": "",- "notes": "",- "due_date": "",- "show_completed": false,- "show_hidden": false,- "max_results": 100,- "task_id": "",- "update_title": "",- "update_notes": "",- "update_due_date": "",- "status": "",- "label": "Tasks"- },- "contacts-1772074610122": {- "operation": "list",- "account_mode": "owner",- "customer_id": "",- "first_name": "",- "last_name": "",- "email": "",- "phone": "",- "company": "",- "job_title": "",- "contact_notes": "",- "page_size": 100,- "sort_order": "LAST_MODIFIED_DESCENDING",- "page_token": "",- "query": "",- "search_page_size": 30,- "resource_name": "",- "update_first_name": "",- "update_last_name": "",- "update_email": "",- "update_phone": "",- "update_company": "",- "update_job_title": "",- "label": "Contacts"- },- "perplexitySearch-1772075707557": {- "toolName": "perplexity_search",- "toolDescription": "Search the web using Perplexity Sonar AI. Returns an AI-generated answer with citations and source URLs.",- "query": "",- "model": "sonar",- "searchRecencyFilter": "",- "returnImages": false,- "returnRelatedQuestions": false,- "label": "Perplexity Search"- },- "braveSearch-1772075714278": {- "toolName": "brave_search",- "toolDescription": "Search the web using Brave Search. Returns web results with titles, snippets, and URLs.",- "query": "",- "maxResults": 10,- "country": "",- "searchLang": "",- "safeSearch": "moderate",- "label": "Brave Search"- },- "typescriptExecutor-1772075756858": {- "code": "// TypeScript Executor - Transform and process data with type safety\n//\n// Available:\n// input_data - object with connected node outputs\n// console.log() - for debugging\n//\n// Set the \"output\" variable with your result\n\ninterface Result {\n message: string;\n input_received: unknown;\n processed: boolean;\n}\n\n// Example: Get data from connected node\nconst data = input_data?.start || input_data || {};\n\n// Process data with type safety\nconst result: Result = {\n message: \"Hello from TypeScript!\",\n input_received: data,\n processed: true\n};\n\n// Set output (required)\noutput = result;",- "label": "TypeScript Executor"- },- "telegramReceive-1772725517789": {- "contentTypeFilter": "text",- "senderFilter": "self",- "chat_id": "",- "from_user": "",- "keywords": "",- "ignoreBots": true,- "label": "Telegram Receive"- },- "telegramSend-1772781380014": {- "recipient_type": "self",- "chat_id": "",- "message_type": "text",- "text": "{{zeenie.response}}",- "media_url": "",- "caption": "",- "latitude": 0,- "longitude": 0,- "phone_number": "",- "first_name": "",- "last_name": "",- "parse_mode": "Auto",- "silent": false,- "reply_to_message_id": 0,- "label": "Telegram Send"- }- }-}\ No newline at end of file