programgarden-core 2.3.0__tar.gz → 2.5.0__tar.gz

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden-core
-Version: 2.3.0
+Version: 2.5.0
 Summary: ProgramGarden Core - 노드 기반 DSL 핵심 타입 정의
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/programgarden_core/i18n/locales/en.json

@@ -112,7 +112,7 @@
   "nodes.NewOrderNode.name": "New Order",
   "nodes.OverseasFuturesAccountNode.description": "Retrieves overseas futures holdings, margin balance, and position details as a one-time REST API snapshot. Outputs held_symbols, balance (margin, maintenance margin, available margin), and positions (per-contract quantity, average cost, unrealized P&L). Requires an upstream OverseasFuturesBrokerNode for authentication. Use OverseasFuturesOpenOrdersNode separately for pending orders. For real-time updates, use OverseasFuturesRealAccountNode instead. Can be used as an AI Agent tool.",
   "nodes.OverseasFuturesAccountNode.name": "Futures Account",
-  "nodes.OverseasFuturesBrokerNode.description": "Establishes an LS Securities OpenAPI connection for overseas futures trading (CME, EUREX, SGX, HKEX). Acts as the authentication gateway — downstream account, market data, and order nodes automatically inherit this broker connection through DAG traversal. Requires credential_id referencing broker_ls_overseas_futures credentials. Supports paper trading mode for risk-free testing. Typical connection: StartNode → OverseasFuturesBrokerNode → FuturesAccountNode / FuturesMarketDataNode / FuturesNewOrderNode.",
+  "nodes.OverseasFuturesBrokerNode.description": "Establishes an LS Securities OpenAPI connection for overseas futures trading (CME, EUREX, SGX, HKEX and others — which of them an account opens differs per account). Acts as the authentication gateway — downstream account, market data, and order nodes automatically inherit this broker connection through DAG traversal. Requires credential_id referencing broker_ls_overseas_futures credentials. Works with BOTH live and paper-trading accounts — it follows the mode of the credential you registered (paper trading is risk-free practice; live trading is equally supported). Which exchanges an account opens differs per account, so confirm with an orderable-symbol lookup. Typical connection: StartNode → OverseasFuturesBrokerNode → FuturesAccountNode / FuturesMarketDataNode / FuturesNewOrderNode.",
   "nodes.OverseasFuturesBrokerNode.name": "Futures Broker",
   "nodes.OverseasFuturesCancelOrderNode.description": "Cancels a pending overseas futures order by its original order ID. Requires original_order_id from FuturesOpenOrdersNode or FuturesRealOrderEventNode. Outputs cancel result and cancelled order ID. Rate-limited to 5-second minimum interval. Typical connection: FuturesOpenOrdersNode → FuturesCancelOrderNode.",
   "nodes.OverseasFuturesCancelOrderNode.name": "Futures Cancel Order",
@@ -294,7 +294,9 @@
   "fields.PerformanceReportNode.benchmark": "Optional benchmark series (same format as data). When provided, beta and alpha are added to metrics.",
   "fields.PerformanceReportNode.periods_per_year": "Annualization factor (252 for daily, 12 for monthly data). Default 252.",
   "fields.PerformanceReportNode.risk_free_rate": "Annual risk-free rate as a fraction (e.g. 0.02 for 2%) for Sharpe/Sortino. Default 0.",
+  "fields.HTTPRequestNode.auth_required": "Does the API require authentication? Leave unset to let the chatbot decide from context; set true for private APIs (a credential is then required), false for public APIs.",
   "fields.HTTPRequestNode.body": "Request body for POST/PUT/PATCH. Automatically serialized to JSON.",
+
   "fields.HTTPRequestNode.credential_id": "Credential ID for authentication. Supports: http_bearer, http_header, http_basic, http_query",
   "fields.HTTPRequestNode.headers": "HTTP headers. Click + to add custom headers (e.g., Content-Type, X-API-Key).",
   "fields.HTTPRequestNode.method": "HTTP method for the request",
@@ -598,7 +600,9 @@
   "fieldNames.PerformanceReportNode.benchmark": "Benchmark",
   "fieldNames.PerformanceReportNode.periods_per_year": "Periods / Year",
   "fieldNames.PerformanceReportNode.risk_free_rate": "Risk-Free Rate",
+  "fieldNames.HTTPRequestNode.auth_required": "Requires Auth",
   "fieldNames.HTTPRequestNode.body": "Request Body",
+
   "fieldNames.HTTPRequestNode.credential_id": "Credential",
   "fieldNames.HTTPRequestNode.headers": "Headers",
   "fieldNames.HTTPRequestNode.method": "HTTP Method",
@@ -872,6 +876,8 @@
   "ports.http_error": "Error message",
   "ports.http_request_data": "Request data",
   "ports.http_response": "API response data",
+  "ports.http_results": "Per-item results (one {item, response, status_code, success, error} entry per iterated item)",
+
   "ports.http_status_code": "HTTP status code",
   "ports.http_success": "Request success flag",
   "ports.items": "Item list",
@@ -1194,7 +1200,14 @@
   "connection_rules.realtime_to_ai_agent.suggestion": "Place a ThrottleNode between the realtime node and AI Agent to control call frequency.",
   "connection_rules.realtime_to_external_api.reason": "Direct connection from realtime node to external API node is not recommended. Each tick would trigger an external API request, potentially hitting rate limits.",
   "connection_rules.realtime_to_external_api.suggestion": "Place a ThrottleNode between the realtime node and external API node to control request frequency.",
+  "connection.HTTPRequestNode.label": "API key",
+  "connection.KoreaStockBrokerNode.label": "LS Securities Korea stock account",
+  "connection.LLMModelNode.label": "AI model key",
+  "connection.OverseasFuturesBrokerNode.label": "LS Securities overseas futures account",
+  "connection.OverseasStockBrokerNode.label": "LS Securities overseas stock account",
+  "connection.TelegramNode.label": "Telegram bot",
   "connection_rules.realtime_to_http.reason": "Direct connection from realtime node to HTTPRequestNode is not recommended. Each tick would trigger an HTTP request, potentially hitting external API rate limits.",
+
   "connection_rules.realtime_to_http.suggestion": "Place a ThrottleNode between the realtime node and HTTP request node to control request frequency.",
   "fields.BaseOrderNode.rate_limit_interval": "Minimum order interval (seconds). Default 5 seconds. The next order will only execute after this time has elapsed since the last order.",
   "fields.BaseOrderNode.rate_limit_action": "Action when order interval is not met. skip: silently skip, error: raise error",

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/programgarden_core/i18n/locales/ko.json

@@ -112,7 +112,7 @@
   "nodes.NewOrderNode.name": "신규 주문",
   "nodes.OverseasFuturesAccountNode.description": "해외선물 보유종목, 증거금 잔고, 포지션 상세를 REST API 1회 조회로 가져옵니다. 출력: held_symbols, balance (증거금, 유지증거금, 가용증거금), positions (계약별 수량, 평균 단가, 미실현 손익). 상위 OverseasFuturesBrokerNode 연결 필수. 미체결 주문은 OverseasFuturesOpenOrdersNode를 별도로 사용하세요. 실시간 업데이트가 필요하면 OverseasFuturesRealAccountNode를 사용하세요. AI Agent 도구로 사용 가능.",
   "nodes.OverseasFuturesAccountNode.name": "해외선물 계좌 조회",
-  "nodes.OverseasFuturesBrokerNode.description": "해외선물 거래를 위한 LS증권 OpenAPI 연결을 설정합니다(CME, EUREX, SGX, HKEX). 인증 게이트웨이 역할 — 하위 계좌, 시세, 주문 노드가 DAG 순회를 통해 자동으로 브로커 연결을 상속합니다. credential_id로 broker_ls_overseas_futures 인증 정보를 참조합니다. 위험 없는 테스트를 위한 모의투자 모드를 지원합니다. 일반적인 연결: StartNode → OverseasFuturesBrokerNode → FuturesAccountNode / FuturesMarketDataNode / FuturesNewOrderNode.",
+  "nodes.OverseasFuturesBrokerNode.description": "해외선물 거래를 위한 LS증권 OpenAPI 연결을 설정합니다(CME·EUREX·SGX·HKEX 등 — 어느 거래소가 열려 있는지는 계좌마다 다릅니다). 인증 게이트웨이 역할 — 하위 계좌, 시세, 주문 노드가 DAG 순회를 통해 자동으로 브로커 연결을 상속합니다. credential_id로 broker_ls_overseas_futures 인증 정보를 참조합니다. 실계좌와 모의투자 계좌를 모두 지원합니다 — 등록한 자격증명의 모드를 그대로 따릅니다(모의투자는 위험 없는 연습용이고, 실거래도 그대로 가능합니다). 계좌가 여는 거래소는 계좌마다 다르므로, 주문 가능 종목 조회로 확인하세요. 일반적인 연결: StartNode → OverseasFuturesBrokerNode → FuturesAccountNode / FuturesMarketDataNode / FuturesNewOrderNode.",
   "nodes.OverseasFuturesBrokerNode.name": "해외선물 브로커",
   "nodes.OverseasFuturesCancelOrderNode.description": "해외선물 미체결 주문을 원래 주문 ID로 취소합니다. FuturesOpenOrdersNode 또는 FuturesRealOrderEventNode에서 original_order_id를 받아야 합니다. 출력: 취소 결과, 취소된 주문 ID. 최소 5초 간격 제한 적용. 일반적인 연결: FuturesOpenOrdersNode → FuturesCancelOrderNode.",
   "nodes.OverseasFuturesCancelOrderNode.name": "해외선물 취소주문",
@@ -294,7 +294,9 @@
   "fields.PerformanceReportNode.benchmark": "선택 벤치마크 시계열(data 와 동일 형식). 지정 시 beta/alpha 가 지표에 추가됩니다.",
   "fields.PerformanceReportNode.periods_per_year": "연율화 계수(일간 252, 월간 12). 기본 252.",
   "fields.PerformanceReportNode.risk_free_rate": "무위험 수익률(소수, 예 0.02=2%) — Sharpe/Sortino용. 기본 0.",
+  "fields.HTTPRequestNode.auth_required": "이 API 가 인증이 필요한가요? 미설정이면 챗봇이 문맥으로 판단합니다. 비공개 API 는 true(자격증명 필요), 공개 API 는 false 로 두세요.",
   "fields.HTTPRequestNode.body": "요청 본문 (POST/PUT/PATCH용). 자동으로 JSON 직렬화됨.",
+
   "fields.HTTPRequestNode.credential_id": "인증정보 ID. 지원: http_bearer, http_header, http_basic, http_query",
   "fields.HTTPRequestNode.headers": "HTTP 헤더. + 버튼으로 커스텀 헤더 추가 (예: Content-Type, X-API-Key).",
   "fields.HTTPRequestNode.method": "HTTP 요청 메서드",
@@ -598,7 +600,9 @@
   "fieldNames.PerformanceReportNode.benchmark": "벤치마크",
   "fieldNames.PerformanceReportNode.periods_per_year": "연간 관측수",
   "fieldNames.PerformanceReportNode.risk_free_rate": "무위험 수익률",
+  "fieldNames.HTTPRequestNode.auth_required": "인증 필요 여부",
   "fieldNames.HTTPRequestNode.body": "요청본문",
+
   "fieldNames.HTTPRequestNode.credential_id": "인증정보",
   "fieldNames.HTTPRequestNode.headers": "헤더",
   "fieldNames.HTTPRequestNode.method": "HTTP메소드",
@@ -872,6 +876,8 @@
   "ports.http_error": "에러 메시지",
   "ports.http_request_data": "요청 데이터",
   "ports.http_response": "API 응답 데이터",
+  "ports.http_results": "항목별 결과 (반복된 항목마다 {item, response, status_code, success, error} 한 건)",
+
   "ports.http_status_code": "HTTP 상태 코드",
   "ports.http_success": "요청 성공 여부",
   "ports.items": "아이템 목록",
@@ -1194,7 +1200,14 @@
   "connection_rules.realtime_to_ai_agent.suggestion": "실시간 노드와 AI Agent 사이에 ThrottleNode를 배치하여 호출 빈도를 제어하세요.",
   "connection_rules.realtime_to_external_api.reason": "실시간 노드에서 외부 API 노드로의 직접 연결은 권장하지 않습니다. 틱 데이터마다 외부 API 요청이 발생하여 rate limit에 걸릴 수 있습니다.",
   "connection_rules.realtime_to_external_api.suggestion": "실시간 노드와 외부 API 노드 사이에 ThrottleNode를 배치하여 요청 빈도를 제어하세요.",
+  "connection.HTTPRequestNode.label": "API 키",
+  "connection.KoreaStockBrokerNode.label": "LS증권 국내주식 계좌",
+  "connection.LLMModelNode.label": "AI 모델 키",
+  "connection.OverseasFuturesBrokerNode.label": "LS증권 해외선물 계좌",
+  "connection.OverseasStockBrokerNode.label": "LS증권 해외주식 계좌",
+  "connection.TelegramNode.label": "텔레그램 봇",
   "connection_rules.realtime_to_http.reason": "실시간 노드에서 HTTPRequestNode로의 직접 연결은 권장하지 않습니다. 틱 데이터마다 HTTP 요청이 발생하여 외부 API 제한에 걸릴 수 있습니다.",
+
   "connection_rules.realtime_to_http.suggestion": "실시간 노드와 HTTP 요청 노드 사이에 ThrottleNode를 배치하여 요청 빈도를 제어하세요.",
   "fields.BaseOrderNode.rate_limit_interval": "최소 주문 간격 (초). 기본값 5초. 직전 주문 후 이 시간이 지나야 다음 주문이 실행됩니다.",
   "fields.BaseOrderNode.rate_limit_action": "주문 간격 미달 시 동작. skip: 조용히 건너뜀, error: 에러 발생",

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/programgarden_core/models/credential.py

@@ -126,7 +126,7 @@ BUILTIN_CREDENTIAL_SCHEMAS: Dict[str, CredentialTypeSchema] = {
         }
     ),
     # ============================================================
-    # LS증권 해외선물 (overseas_futures) - 모의투자 지원
+    # LS증권 해외선물 (overseas_futures) - 실거래·모의투자 둘 다 지원(등록 폼에서 모드 선택)
     # ============================================================
     "broker_ls_overseas_futures": CredentialTypeSchema(
         type_id="broker_ls_overseas_futures",

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/programgarden_core/nodes/ai.py

@@ -42,6 +42,17 @@ class LLMModelNode(BaseNode):
     type: Literal["LLMModelNode"] = "LLMModelNode"
     category: NodeCategory = NodeCategory.AI
 
+    # 연결(자격증명) 선언 — 챗봇/편집기/검증기 공용. AI 모델 키는 실행에 반드시 필요하다.
+    _connection: ClassVar[Dict[str, Any]] = {
+        "purpose": "ai",
+        "need": "run",
+        "when": "always",
+        "label_key": "connection.LLMModelNode.label",
+        "presets": [],
+        "missing": "draft",
+    }
+
+
     # === LLM 설정 ===
     credential_id: Optional[str] = Field(
         default=None,

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/programgarden_core/nodes/broker.py

@@ -81,6 +81,19 @@ class OverseasStockBrokerNode(BaseBrokerNode):
     _product_scope: ClassVar[ProductScope] = ProductScope.STOCK
     _broker_provider: ClassVar[BrokerProvider] = BrokerProvider.LS
 
+    # 연결(자격증명) 선언 — 챗봇/편집기/검증기 공용. types 는 credential_id 필드의
+    # credential_types 에서 자동 추출된다. 이 계좌를 상속하는 시세/계좌/주문 노드는
+    # 자기 선언 없이 이 브로커 연결을 물려받는다.
+    _connection: ClassVar[Dict[str, Any]] = {
+        "purpose": "trading",
+        "need": "run",
+        "when": "always",
+        "label_key": "connection.OverseasStockBrokerNode.label",
+        "presets": [],
+        "missing": "draft",
+    }
+
+
     _usage: ClassVar[Dict[str, Any]] = {
         "when_to_use": [
             "Every workflow that reads overseas stock market data, account state, or places orders",
@@ -268,7 +281,10 @@ class OverseasFuturesBrokerNode(BaseBrokerNode):
     LS증권 OpenAPI를 통해 해외선물 거래를 위한 브로커 연결을 생성합니다.
 
     Note:
-    - 해외선물은 모의투자 지원
+    - 해외선물은 **실거래와 모의투자 둘 다** 지원한다. 등록 폼에서 모드를 고르는 유일한
+      상품이며, ``paper_trading`` 은 등록한 자격증명의 모드를 따른다. (모의투자를 자주
+      쓰는 것은 증거금 비용 때문이지, 실거래가 안 되기 때문이 아니다.)
+    - 계좌가 여는 거래소(CME 등)는 **계좌마다 다르다** — 주문 가능 종목 조회로만 알 수 있다.
     - credential_types: broker_ls_overseas_futures
     """
 
@@ -280,6 +296,19 @@ class OverseasFuturesBrokerNode(BaseBrokerNode):
     _product_scope: ClassVar[ProductScope] = ProductScope.FUTURES
     _broker_provider: ClassVar[BrokerProvider] = BrokerProvider.LS
 
+    # 연결(자격증명) 선언 — 챗봇/편집기/검증기 공용. types 는 credential_id 필드의
+    # credential_types 에서 자동 추출된다. 이 계좌를 상속하는 시세/계좌/주문 노드는
+    # 자기 선언 없이 이 브로커 연결을 물려받는다.
+    _connection: ClassVar[Dict[str, Any]] = {
+        "purpose": "trading",
+        "need": "run",
+        "when": "always",
+        "label_key": "connection.OverseasFuturesBrokerNode.label",
+        "presets": [],
+        "missing": "draft",
+    }
+
+
     _usage: ClassVar[Dict[str, Any]] = {
         "when_to_use": [
             "Every overseas futures workflow — CME ES / NQ, SGX Nikkei, HKEX HSI mini, etc.",
@@ -442,6 +471,19 @@ class KoreaStockBrokerNode(BaseBrokerNode):
     _product_scope: ClassVar[ProductScope] = ProductScope.KOREA_STOCK
     _broker_provider: ClassVar[BrokerProvider] = BrokerProvider.LS
 
+    # 연결(자격증명) 선언 — 챗봇/편집기/검증기 공용. types 는 credential_id 필드의
+    # credential_types 에서 자동 추출된다. 이 계좌를 상속하는 시세/계좌/주문 노드는
+    # 자기 선언 없이 이 브로커 연결을 물려받는다.
+    _connection: ClassVar[Dict[str, Any]] = {
+        "purpose": "trading",
+        "need": "run",
+        "when": "always",
+        "label_key": "connection.KoreaStockBrokerNode.label",
+        "presets": [],
+        "missing": "draft",
+    }
+
+
     _usage: ClassVar[Dict[str, Any]] = {
         "when_to_use": [
             "Every KRX-listed (KOSPI / KOSDAQ / NXT) stock workflow",

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/programgarden_core/nodes/data.py

@@ -552,6 +552,24 @@ class HTTPRequestNode(BaseNode):
         on_throttle="skip",
     )
 
+    # 연결(자격증명) 선언 — 챗봇/편집기/검증기 공용. HTTP 는 인증형 API 일 때만 키가
+    # 필요(when=auth_required, auth_required 설정 참조)하고, 실제 응답 검증에도 필요해
+    # need=validate 다. FMP/Finnhub 는 http_query 프리셋으로 param_name 을 잡아준다.
+    _connection: ClassVar[Dict[str, Any]] = {
+        "purpose": "data",
+        "need": "validate",
+        "when": "auth_required",
+        "label_key": "connection.HTTPRequestNode.label",
+        "presets": [
+            {"id": "fmp", "label": "FMP", "type": "http_query",
+             "fields": {"param_name": "apikey"}},
+            {"id": "finnhub", "label": "Finnhub", "type": "http_query",
+             "fields": {"param_name": "token"}},
+        ],
+        "missing": "draft",
+    }
+
+
     # === PARAMETERS: 핵심 HTTP 요청 설정 ===
     method: Literal["GET", "POST", "PUT", "PATCH", "DELETE"] = Field(
         default="GET",
@@ -573,6 +591,15 @@ class HTTPRequestNode(BaseNode):
     # === SETTINGS: 부가 설정 ===
     timeout_seconds: int = Field(default=30, description="Request timeout (seconds)")
 
+    # 이 API 가 인증이 필요한가(비공개 키). None = 챗봇이 판단(기본) — 문맥으로 결정한다.
+    # True = 인증 필요(credential 없으면 검증/실행 불가), False = 공개 API(credential 불필요).
+    # 기본값을 False 로 두면 비공개 API 에 위험하므로 None(미지정)으로 둔다.
+    # `connection.when="auth_required"` 가 이 값을 참조한다.
+    auth_required: Optional[bool] = Field(
+        default=None,
+        description="Does this API require authentication? None = chatbot decides (default), True = auth required, False = public.",
+    )
+
     # === Resilience: 재시도/실패 처리 (H-21: HTTP 요청은 기본 재시도 활성화) ===
     resilience: ResilienceConfig = Field(
         default_factory=lambda: ResilienceConfig(
@@ -606,6 +633,7 @@ class HTTPRequestNode(BaseNode):
         "Rate-limited: minimum 1-second interval and max 3 concurrent calls; real-time node connections blocked",
         "is_tool_enabled=True — AI Agent can invoke HTTPRequestNode as a tool to fetch live external data",
         "Outputs response (parsed JSON or raw text), status_code, success flag, and error string for downstream branching",
+        "Runs once per upstream list element when the config references {{ item… }}/{{ index }}/{{ total }} (e.g. one request per watchlist symbol); the per-item outcomes are exposed on the `results` array port while response/status_code/success/error hold the last item's values. A config without an item reference runs once (unchanged).",
     ]
     _anti_patterns: ClassVar[List[Dict[str, str]]] = [
         {
@@ -693,7 +721,7 @@ class HTTPRequestNode(BaseNode):
     ]
     _node_guide: ClassVar[Dict[str, Any]] = {
         "input_handling": "The 'url' field is the only required config. Use 'body' for POST/PUT/PATCH payloads (auto-serialized to JSON). Use 'query_params' for GET parameters. The 'data' input port can supply dynamic values from upstream nodes via expression.",
-        "output_consumption": "Check 'success' (boolean) before consuming 'response'. On failure, 'error' contains the HTTP status string. 'response' is auto-parsed JSON when the Content-Type is application/json, otherwise raw text.",
+        "output_consumption": "Check 'success' (boolean) before consuming 'response'. On failure, 'error' contains the HTTP status string. 'response' is auto-parsed JSON when the Content-Type is application/json, otherwise raw text. When the config references {{ item… }} the node runs once per upstream item: read the 'results' array (one {item, response, status_code, success, error} entry per item, in order) for per-item outcomes; 'response'/'status_code'/'success'/'error' then reflect the LAST item, and top-level 'success' is the AND of all items while top-level 'error' is set only when every item failed.",
         "common_combinations": [
             "StartNode → HTTPRequestNode (GET) → FieldMappingNode → ConditionNode",
             "ConditionNode → HTTPRequestNode (POST webhook) → SummaryDisplayNode",
@@ -719,13 +747,32 @@ class HTTPRequestNode(BaseNode):
         OutputPort(name="status_code", type="number", description="i18n:ports.http_status_code"),
         OutputPort(name="success", type="boolean", description="i18n:ports.http_success"),
         OutputPort(name="error", type="string", description="i18n:ports.http_error"),
+        # Per-item results when the node auto-iterates over an upstream list
+        # (config references {{ item… }}/{{ index }}/{{ total }}). One entry per
+        # item, in order: {item, response, status_code, success, error}. A node
+        # that does not reference an iteration item runs once and this array holds
+        # that single execution. `response`/`status_code`/`success`/`error` above
+        # stay as the LAST item's scalar values (backward compatible with
+        # {{ nodes.x.response }}).
+        OutputPort(
+            name="results", type="array",
+            description="i18n:ports.http_results",
+            example=[
+                {"item": {"symbol": "AAPL", "exchange": "NASDAQ"},
+                 "response": {"price": 189.2}, "status_code": 200,
+                 "success": True, "error": None},
+            ],
+        ),
     ]
 
     _field_schema: ClassVar[Dict[str, "FieldSchema"]] = {}
 
-    _version: ClassVar[str] = "1.0.0"
-    _updated_at: ClassVar[str] = "2026-05-19"
-    _change_note: ClassVar[Optional[str]] = None
+    _version: ClassVar[str] = "1.1.0"
+    _updated_at: ClassVar[str] = "2026-09-28"
+    _change_note: ClassVar[Optional[str]] = (
+        "Added `results` port: one entry per iterated item ({{ item }} refs); "
+        "scalar ports keep the last item's value."
+    )
 
     @classmethod
     def get_field_schema(cls) -> Dict[str, "FieldSchema"]:
@@ -812,6 +859,16 @@ class HTTPRequestNode(BaseNode):
                 max_value=300,
                 group="advanced",
             ),
+            "auth_required": FieldSchema(
+                name="auth_required", type=FieldType.BOOLEAN, required=False,
+                description="i18n:fields.HTTPRequestNode.auth_required",
+                category=FieldCategory.SETTINGS,
+                expression_mode=ExpressionMode.FIXED_ONLY,
+                example=True,
+                expected_type="bool",
+                group="advanced",
+            ),
+
             # === RESILIENCE: 재시도/실패 처리 (단순화된 UI) ===
             "resilience": FieldSchema(
                 name="resilience", type=FieldType.OBJECT, required=False,

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/programgarden_core/nodes/trigger.py

@@ -50,17 +50,29 @@ class ScheduleNode(BaseNode):
         default="America/New_York", description="Timezone (e.g., America/New_York, Asia/Seoul)"
     )
     enabled: bool = Field(default=True, description="Schedule enabled")
-    max_duration_hours: float = Field(
-        default=24.0,
-        description="최대 실행 시간 (시간). 초과 시 스케줄 자동 종료.",
+    # None (omitted) = unbounded: run until the workflow is stopped. Owner
+    # decision 2026-09-26: when the investor names no duration, the bot keeps
+    # running on its cron until the user stops the workflow. A provided value
+    # is still enforced (> 0) as a cap.
+    max_duration_hours: Optional[float] = Field(
+        default=None,
+        description=(
+            "최대 실행 시간 (시간). 생략(None)하면 사용자가 워크플로우를 멈출 때까지 "
+            "계속 실행한다. 값을 지정하면 초과 시 스케줄 자동 종료 (지정 시 반드시 > 0)."
+        ),
     )
     # ⑭ count was read by the executor (config.get("count", 1000)) but not
     # declared on the model — that schema/executor duality meant a canonical
-    # field was invisible to validation. Declared here (default matches the
-    # executor's safety cap) so the model is the single source of truth.
-    count: int = Field(
-        default=1000,
-        description="Max number of schedule cycles before the scheduler exits (safety cap alongside max_duration_hours).",
+    # field was invisible to validation. Now declared here. None (omitted) =
+    # unbounded: run until the workflow is stopped (owner 2026-09-26). A
+    # provided value is enforced (>= 1) as a cycle cap.
+    count: Optional[int] = Field(
+        default=None,
+        description=(
+            "Max number of schedule cycles before the scheduler exits. Omit "
+            "(None) to run until the workflow is stopped; set only when the "
+            "investor named a fixed number of cycles (>= 1)."
+        ),
     )
 
     _inputs: List[InputPort] = []
@@ -76,7 +88,7 @@ class ScheduleNode(BaseNode):
     _usage: ClassVar[Dict[str, Any]] = {
         "when_to_use": [
             "Run the main flow on a cron schedule (every N minutes, daily at 09:30 ET, weekly market close, …)",
-            "Bound long-running workflows with max_duration_hours to avoid runaway schedulers",
+            "Run indefinitely until the user stops the workflow — omit max_duration_hours and count; set them only when the investor named a duration or cycle count",
             "Combine with TradingHoursFilterNode to fire only on weekdays within market hours",
         ],
         "when_not_to_use": [
@@ -93,12 +105,12 @@ class ScheduleNode(BaseNode):
     _features: ClassVar[List[str]] = [
         "Standard 5-field cron expression — minute / hour / day / month / weekday",
         "Timezone-aware (IANA names) — 'America/New_York', 'Asia/Seoul', 'UTC'",
-        "max_duration_hours caps total runtime; the scheduler exits cleanly at the limit",
+        "max_duration_hours and count are optional bounds: omit both and the schedule runs until the workflow is stopped; set one and the scheduler exits cleanly at that limit",
         "enabled=False freezes the trigger without removing the node from the DAG",
         "A tick re-executes the whole main flow: the ScheduleNode returns {trigger: true} without re-registering, so every node downstream of it runs again on each tick",
         "Startup account and open-order snapshots are not retained across schedule ticks; they are retained only across realtime events",
         "In replay a schedule_tick must fall on the cron's next firing instant after the previous frame, evaluated in this node's timezone (default America/New_York)",
-        "enabled=false emits no tick; ticks past count or max_duration_hours are refused; an invalid timezone is rejected at startup",
+        "enabled=false emits no tick; when count / max_duration_hours are set, ticks past them are refused; when both are omitted the schedule is unbounded (runs until stopped); an invalid timezone is rejected at startup",
         "Emits exactly one subsequent event type: schedule_tick",
         "Requires exactly one StartNode upstream; the ScheduleNode is never the workflow root",
     ]
@@ -177,7 +189,7 @@ class ScheduleNode(BaseNode):
         },
     ]
     _node_guide: ClassVar[Dict[str, Any]] = {
-        "input_handling": "No data inputs. All behavior is configured via `cron`, `timezone`, `enabled`, `max_duration_hours`.",
+        "input_handling": "No data inputs. All behavior is configured via `cron`, `timezone`, `enabled`, and the optional bounds `max_duration_hours` / `count` (omit both to run until the workflow is stopped).",
         "output_consumption": "`trigger` output carries `{fired_at, cycle_index}`. Downstream nodes usually just need an incoming edge; explicit binding is optional.",
         "common_combinations": [
             "StartNode → ScheduleNode → trading body (plain cron workflow)",
@@ -187,7 +199,7 @@ class ScheduleNode(BaseNode):
         "pitfalls": [
             "Always set `timezone` explicitly — server defaults are not portable",
             "Pair with TradingHoursFilterNode when the cron expression does not already encode market hours",
-            "max_duration_hours caps the total runtime; for indefinite bots set it generously (up to 720h)",
+            "For a bot that should run until the user stops it, omit max_duration_hours and count; set them only when the investor named a duration (max_duration_hours > 0) or a cycle count (count >= 1)",
         ],
     }
 
@@ -237,9 +249,11 @@ class ScheduleNode(BaseNode):
                 name="max_duration_hours",
                 type=FieldType.NUMBER,
                 description="i18n:fields.ScheduleNode.max_duration_hours",
-                default=24.0,
+                # No default and NO max_value: omit for an unbounded schedule
+                # that runs until the workflow is stopped (owner 2026-09-26).
+                # Only a provided value is bounded (> 0).
+                default=None,
                 min_value=0.1,
-                max_value=720.0,
                 expression_mode=ExpressionMode.FIXED_ONLY,
                 category=FieldCategory.SETTINGS,
                 expected_type="float",
@@ -248,8 +262,9 @@ class ScheduleNode(BaseNode):
             "count": FieldSchema(
                 name="count",
                 type=FieldType.INTEGER,
-                description="Max number of schedule cycles before the scheduler exits (safety cap alongside max_duration_hours).",
-                default=1000,
+                description="Max number of schedule cycles before the scheduler exits. Omit for an unbounded schedule that runs until the workflow is stopped; set only when a fixed number of cycles is intended.",
+                # No default: omitted = unbounded (owner 2026-09-26).
+                default=None,
                 min_value=1,
                 expression_mode=ExpressionMode.FIXED_ONLY,
                 category=FieldCategory.SETTINGS,

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/programgarden_core/registry/node_registry.py

@@ -9,7 +9,7 @@ from typing import Optional, List, Dict, Any, Type
 from pydantic import BaseModel, Field
 
 from programgarden_core.nodes.base import BaseNode, NodeCategory, InputPort, OutputPort, ProductScope, BrokerProvider
-from programgarden_core.i18n import translate_schema, translate_category
+from programgarden_core.i18n import translate_schema, translate_category, t
 
 
 class NodeTypeSchema(BaseModel):
@@ -112,6 +112,26 @@ class NodeTypeSchema(BaseModel):
             "time_rules, venue."
         ),
     )
+    connection: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description=(
+            "Credential/connection declaration — one place the chatbot, editor "
+            "and validator read a node's credential need. Built by the core "
+            "registry from the node's `_connection` ClassVar + its credential "
+            "field's `credential_types` (locale-independent: both label_ko and "
+            "label_en are always present). None when the node needs no credential "
+            "of its own — broker-connected nodes (market data / account / order) "
+            "inherit their upstream broker's connection and declare nothing. "
+            "Keys (all present when set): types (== credential_types), purpose "
+            "(trading|data|ai|notify), need (run|validate|optional; run = needed "
+            "only to execute, validate = also needed for real-response "
+            "validation), when (always|auth_required|never; auth_required = only "
+            "when the node config marks the API authenticated), label_ko, "
+            "label_en (plain user-facing names), presets (HTTPRequestNode only; "
+            "[] elsewhere), missing (draft = may be saved without it and the run "
+            "gate blocks; block = must exist before build)."
+        ),
+    )
 
     # === Version metadata (UI change detection) ===
     version: str = Field(
@@ -388,6 +408,14 @@ class NodeTypeRegistry:
 
         config_schema = self._build_config_schema(node_class, type_name)
 
+        # 연결(자격증명) 선언 직렬화 (_connection ClassVar → 챗봇/편집기/검증기 공용 dict).
+        # types 는 노드의 credential 필드가 export 한 credential_types 에서 그대로 뽑아
+        # 항상 동기화한다(별도 선언 안 함). label_ko/label_en 은 i18n 키를 양 언어로
+        # 즉시 해석해 locale-독립적으로 둘 다 싣는다(포트/설명과 달리 get_schema(locale)
+        # 재번역에 의존하지 않음). credential 필드가 없거나 _connection 미선언이면 None
+        # (브로커 연결을 상속하는 시세/계좌/주문 노드는 자기 선언이 없다).
+        connection = self._build_connection(node_class, config_schema)
+
         # Display 노드의 런타임 데이터 스키마
         display_data_schema = getattr(node_class, '_display_data_schema', None)
 
@@ -423,6 +451,7 @@ class NodeTypeRegistry:
             outputs=outputs,
             config_schema=config_schema,
             display_data_schema=display_data_schema,
+            connection=connection,
             connection_rules=serialized_connection_rules,
             rate_limit=serialized_rate_limit,
             usage=getattr(node_class, "_usage", None),
@@ -463,6 +492,45 @@ class NodeTypeRegistry:
 
         return result
 
+    # 닫힌 값 집합 — 잘못된 선언을 조기에 잡는다(테스트에서도 이 집합으로 검증).
+    _CONNECTION_PURPOSES = ("trading", "data", "ai", "notify")
+    _CONNECTION_NEEDS = ("run", "validate", "optional")
+    _CONNECTION_WHENS = ("always", "auth_required", "never")
+    _CONNECTION_MISSINGS = ("draft", "block")
+
+    def _build_connection(
+        self, node_class: Type[BaseNode], config_schema: Dict[str, Any],
+    ) -> Optional[Dict[str, Any]]:
+        """`_connection` ClassVar + credential_types → 공용 connection 선언.
+
+        모든 키가 항상 존재한다. `types` 는 config_schema 안 credential 필드가 export 한
+        `credential_types` 의 합집합이라 선언과 어긋나지 않는다. `label_ko`/`label_en` 은
+        `label_key` i18n 키를 양 언어로 해석해 둘 다 싣는다(locale-독립).
+        """
+        decl = getattr(node_class, "_connection", None)
+        if not decl:
+            return None
+
+        cred_types: List[str] = []
+        for field_cfg in config_schema.values():
+            if not isinstance(field_cfg, dict):
+                continue
+            for ct in field_cfg.get("credential_types") or []:
+                if ct not in cred_types:
+                    cred_types.append(ct)
+
+        label_key = decl.get("label_key", "")
+        return {
+            "types": cred_types,
+            "purpose": decl["purpose"],
+            "need": decl["need"],
+            "when": decl["when"],
+            "label_ko": t(label_key, "ko") if label_key else "",
+            "label_en": t(label_key, "en") if label_key else "",
+            "presets": [dict(p) for p in decl.get("presets", [])],
+            "missing": decl["missing"],
+        }
+
     def _build_config_schema(self, node_class: Type[BaseNode], node_type: str) -> Dict[str, Any]:
         """
         노드의 필드 스키마를 단순한 config_schema 형식으로 변환합니다.
@@ -516,6 +584,20 @@ class NodeTypeRegistry:
             return NodeTypeSchema(**translated)
         return schema
 
+    def connection_declaration(self, node_type: str) -> Optional[Dict[str, Any]]:
+        """이 노드가 필요로 하는 자격증명/연결 선언(챗봇·편집기·검증기 공용).
+
+        credential 이 필요 없는 노드(브로커 연결을 상속하는 시세/계좌/주문 등)는 None.
+        반환 dict 는 복사본이라 호출부가 수정해도 캐시에 영향 없다.
+        """
+        schema = self._schemas.get(node_type)
+        if schema is None or schema.connection is None:
+            return None
+        conn = dict(schema.connection)
+        conn["types"] = list(conn.get("types", []))
+        conn["presets"] = [dict(p) for p in conn.get("presets", [])]
+        return conn
+
     def list_types(self, category: Optional[str] = None) -> List[str]:
         """List registered node types"""
         if category:

{programgarden_core-2.3.0 → programgarden_core-2.5.0}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden-core"
-version = "2.3.0"
+version = "2.5.0"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden Core - 노드 기반 DSL 핵심 타입 정의"
 readme = "README.md"