Buckets:
| """ | |
| effGen: A comprehensive framework for building agents with Small Language Models. | |
| This framework runs SLMs as agentic systems through: | |
| - Tool integration (built-in tools + MCP/A2A/ACP protocols) | |
| - Advanced prompt engineering optimized for SLMs | |
| - Smart sub-agent decomposition for complex tasks | |
| - Multi-GPU support with vLLM and Transformers | |
| - Comprehensive configuration management | |
| The command-line tools load a nearby ``.env`` automatically. In a script or | |
| notebook, call :func:`effgen.load_env` once to get the same key discovery:: | |
| from effgen import load_env, create_agent | |
| load_env() # reads OPENAI_API_KEY / GROQ_API_KEY / ... from a nearby .env | |
| agent = create_agent("minimal", "groq:llama-3.1-8b-instant") | |
| The public surface (``effgen.__all__``) is resolved **lazily**: importing | |
| ``effgen`` only sets up version metadata and logging hygiene, and the first | |
| access of a name (``effgen.Agent``, ``from effgen import load_model``) imports | |
| just the submodule that defines it. This keeps ``import effgen`` and a bare | |
| version check cheap, and defers heavy/optional dependencies (torch, | |
| transformers, vLLM, provider SDKs) until something that needs them is used. | |
| """ | |
| # ruff: noqa: I001 | |
| __version__ = "1.0.0" | |
| __author__ = "effGen Team" | |
| __license__ = "Apache-2.0" | |
| # Fail early and clearly on an unsupported interpreter. pip already refuses to | |
| # install on < 3.11 (requires-python in pyproject.toml), but a source checkout | |
| # run via PYTHONPATH skips that gate — and effGen's submodules use 3.11+ syntax, | |
| # so without this guard the user would hit a cryptic SyntaxError instead. Keep | |
| # this block free of any 3.11-only syntax so it runs on the wrong interpreter. | |
| import os as _os | |
| import sys as _sys | |
| from importlib import import_module as _import_module | |
| from typing import TYPE_CHECKING, Any | |
| if _sys.version_info < (3, 11): # noqa: UP036 — intentional guard for source-checkout runs on < 3.11 | |
| raise RuntimeError( | |
| "effGen requires Python 3.11 or newer, but you are running " | |
| "{}.{}.{}. Please upgrade your interpreter (e.g. create a Python 3.12 " | |
| "environment) and reinstall effGen.".format(*_sys.version_info[:3]) | |
| ) | |
| # Library logging hygiene (NullHandler on the package logger; quiet faiss). This | |
| # is an import-only module whose side effects run first, before any submodule is | |
| # imported, so importing effGen never emits log records on its own. It is | |
| # intentionally cheap (stdlib logging only). | |
| from effgen import _logging_setup as _logging_setup # noqa: F401 | |
| # --------------------------------------------------------------------------- | |
| # Lazy public surface. | |
| # | |
| # Each entry maps a public name to ``(module, attribute)``. ``__getattr__`` | |
| # imports the module on first access, binds the resolved object into this | |
| # module's globals (so subsequent accesses are a plain dict lookup), and returns | |
| # it. An attribute of ``None`` means the name *is* the submodule itself | |
| # (e.g. ``gpu_utils``). | |
| # | |
| # This mapping is the single source of truth for both ``__getattr__`` and | |
| # ``__dir__``. ``__all__`` (the documented 170-name surface) is derived from it | |
| # below; the extra entries (provider-native tool classes, MLX engines) are | |
| # historically importable but were never in ``__all__``, so they stay out of it. | |
| # --------------------------------------------------------------------------- | |
| _LAZY: dict[str, tuple[str, str | None]] = { | |
| "BackendUnreachableError": ("effgen.models.errors", "BackendUnreachableError"), | |
| "OpenAICompatibleAdapter": ("effgen.models.openai_compatible_adapter", "OpenAICompatibleAdapter"), | |
| "ToolCallList": ("effgen.core.tool_call_record", "ToolCallList"), | |
| "ToolCall": ("effgen.core.tool_call_record", "ToolCall"), | |
| "ToolApprovalMiddleware": ("effgen.core.middleware", "ToolApprovalMiddleware"), | |
| "MiddlewareChain": ("effgen.core.middleware", "MiddlewareChain"), | |
| "LoggingMiddleware": ("effgen.core.middleware", "LoggingMiddleware"), | |
| "SummarizeOldest": ("effgen.memory.compaction", "SummarizeOldest"), | |
| "KeepToolResults": ("effgen.memory.compaction", "KeepToolResults"), | |
| "KeepFirstAndLast": ("effgen.memory.compaction", "KeepFirstAndLast"), | |
| "DropOldest": ("effgen.memory.compaction", "DropOldest"), | |
| "CompactionStrategy": ("effgen.memory.compaction", "CompactionStrategy"), | |
| "Agent": ("effgen.core.agent", "Agent"), | |
| "PartialResult": ("effgen.core.agent_response", "PartialResult"), | |
| "RunStoppedError": ("effgen.errors", "RunStoppedError"), | |
| "AgentConfig": ("effgen.core.agent", "AgentConfig"), | |
| "AgentMiddleware": ("effgen.core.middleware", "AgentMiddleware"), | |
| "AgentEvaluator": ("effgen.eval.evaluator", "AgentEvaluator"), | |
| "AgentState": ("effgen.core.state", "AgentState"), | |
| "AgentSystemPromptBuilder": ("effgen.prompts.agent_system_prompt", "AgentSystemPromptBuilder"), | |
| "Alert": ("effgen.observability.alerting", "Alert"), | |
| "AlertSeverity": ("effgen.observability.alerting", "AlertSeverity"), | |
| "AlertWebhook": ("effgen.observability.alerting", "AlertWebhook"), | |
| "AllCandidatesExhaustedError": ("effgen.models.errors", "AllCandidatesExhaustedError"), | |
| "AmbiguousModelError": ("effgen.models.errors", "AmbiguousModelError"), | |
| "AnthropicAdapter": ("effgen.models.anthropic_adapter", "AnthropicAdapter"), | |
| "AudioPart": ("effgen.core.messages", "AudioPart"), | |
| "BaseModel": ("effgen.models.base", "BaseModel"), | |
| "BaseTool": ("effgen.tools.base_tool", "BaseTool"), | |
| "BatchConfig": ("effgen.core.batch", "BatchConfig"), | |
| "BatchResult": ("effgen.core.batch", "BatchResult"), | |
| "BatchRunner": ("effgen.core.batch", "BatchRunner"), | |
| "BudgetExceededError": ("effgen.models.errors", "BudgetExceededError"), | |
| "CapabilityNotSupportedError": ("effgen.errors", "CapabilityNotSupportedError"), | |
| "CerebrasAdapter": ("effgen.models.cerebras_adapter", "CerebrasAdapter"), | |
| "ChainManager": ("effgen.prompts.chain_manager", "ChainManager"), | |
| "CircuitBreaker": ("effgen.utils.circuit_breaker", "CircuitBreaker"), | |
| # CodeExecutor here is the convenience wrapper that runs code through a | |
| # local subprocess with a static AST/regex validator (or Docker). It is not | |
| # OS-level isolation on the local backend; for a model-facing tool with the | |
| # project's hardened isolation, use the registered `code_executor` tool | |
| # (effgen.tools.builtin.code_executor). See effgen/execution/sandbox.py. | |
| "CodeExecutor": ("effgen.execution.sandbox", "CodeExecutor"), | |
| "CodeValidator": ("effgen.execution.validators", "CodeValidator"), | |
| "Config": ("effgen.config.loader", "Config"), | |
| "ConfigLoader": ("effgen.config.loader", "ConfigLoader"), | |
| "ConfigValidator": ("effgen.config.validator", "ConfigValidator"), | |
| "ContentPart": ("effgen.core.messages", "ContentPart"), | |
| "CostBasedPolicy": ("effgen.models.routing.cost", "CostBasedPolicy"), | |
| "CostTracker": ("effgen.models._cost", "CostTracker"), | |
| "Domain": ("effgen.domains.base", "Domain"), | |
| "EvalResult": ("effgen.eval.evaluator", "EvalResult"), | |
| "ExecutionResult": ("effgen.execution.sandbox", "ExecutionResult"), | |
| "ExecutionStatus": ("effgen.execution.sandbox", "ExecutionStatus"), | |
| "FinanceDomain": ("effgen.domains.presets", "FinanceDomain"), | |
| "FireworksAdapter": ("effgen.models.fireworks_adapter", "FireworksAdapter"), | |
| "FirstAvailablePolicy": ("effgen.models.routing.first_available", "FirstAvailablePolicy"), | |
| "FunctionTool": ("effgen.tools.function_tool", "FunctionTool"), | |
| "GPUAllocator": ("effgen.gpu.allocator", "GPUAllocator"), | |
| "GPUMonitor": ("effgen.gpu.monitor", "GPUMonitor"), | |
| "GeminiAdapter": ("effgen.models.gemini_adapter", "GeminiAdapter"), | |
| "GeminiCodeExecutionTool": ("effgen.tools.builtin.gemini_native", "GeminiCodeExecutionTool"), | |
| "GeminiNativeTool": ("effgen.tools.builtin.gemini_native", "GeminiNativeTool"), | |
| "GeminiUrlContextTool": ("effgen.tools.builtin.gemini_native", "GeminiUrlContextTool"), | |
| "GenerationConfig": ("effgen.models.base", "GenerationConfig"), | |
| "GenerationResult": ("effgen.models.base", "GenerationResult"), | |
| "GoogleSearchTool": ("effgen.tools.builtin.gemini_native", "GoogleSearchTool"), | |
| "GroqAdapter": ("effgen.models.groq_adapter", "GroqAdapter"), | |
| "HFInferenceAdapter": ("effgen.models.hf_inference_adapter", "HFInferenceAdapter"), | |
| "HashDriftWarning": ("effgen.security.supply_chain", "HashDriftWarning"), | |
| "HealthDomain": ("effgen.domains.presets", "HealthDomain"), | |
| "ImagePart": ("effgen.core.messages", "ImagePart"), | |
| "ImportanceLevel": ("effgen.memory.long_term", "ImportanceLevel"), | |
| "InvalidMultimodalContent": ("effgen.errors", "InvalidMultimodalContent"), | |
| "InvalidRequestError": ("effgen.models.errors", "InvalidRequestError"), | |
| "JSONStorageBackend": ("effgen.memory.long_term", "JSONStorageBackend"), | |
| "KeywordExpander": ("effgen.domains.expander", "KeywordExpander"), | |
| "LatencyBasedPolicy": ("effgen.models.routing.latency", "LatencyBasedPolicy"), | |
| "LatencyTracker": ("effgen.models.latency_tracker", "LatencyTracker"), | |
| "LegalDomain": ("effgen.domains.presets", "LegalDomain"), | |
| "LongTermMemory": ("effgen.memory.long_term", "LongTermMemory"), | |
| "MLXEngine": ("effgen.models.mlx_engine", "MLXEngine"), | |
| "MLXVLMEngine": ("effgen.models.mlx_vlm_engine", "MLXVLMEngine"), | |
| "MemoryEntry": ("effgen.memory.long_term", "MemoryEntry"), | |
| "MemoryType": ("effgen.memory.long_term", "MemoryType"), | |
| "MultiAgentOrchestrator": ("effgen.core.orchestrator", "MultiAgentOrchestrator"), | |
| "Message": ("effgen.memory.short_term", "Message"), | |
| "MessageRole": ("effgen.memory.short_term", "MessageRole"), | |
| "ModelAuthError": ("effgen.models.errors", "ModelAuthError"), | |
| "ModelComparison": ("effgen.eval.comparison", "ModelComparison"), | |
| "ModelLoader": ("effgen.models.model_loader", "ModelLoader"), | |
| "ModelNotFoundError": ("effgen.models.errors", "ModelNotFoundError"), | |
| "ModelRefusalError": ("effgen.models.errors", "ModelRefusalError"), | |
| "ModelTimeoutError": ("effgen.models.errors", "ModelTimeoutError"), | |
| "ModelUnavailableError": ("effgen.models.errors", "ModelUnavailableError"), | |
| "MultimodalMessage": ("effgen.core.messages", "Message"), | |
| "NoCandidateWithinBudgetError": ("effgen.models.errors", "NoCandidateWithinBudgetError"), | |
| "OrchestrationPattern": ("effgen.core.orchestrator", "OrchestrationPattern"), | |
| "OpenAIAdapter": ("effgen.models.openai_adapter", "OpenAIAdapter"), | |
| "OpenAICodeInterpreterTool": ("effgen.tools.builtin.openai_native", "OpenAICodeInterpreterTool"), | |
| "OpenAIFileSearchTool": ("effgen.tools.builtin.openai_native", "OpenAIFileSearchTool"), | |
| "OpenAINativeTool": ("effgen.tools.builtin.openai_native", "OpenAINativeTool"), | |
| "OpenAIWebSearchTool": ("effgen.tools.builtin.openai_native", "OpenAIWebSearchTool"), | |
| "PolicyBasedRouter": ("effgen.models.router", "PolicyBasedRouter"), | |
| "PromptOptimizer": ("effgen.prompts.optimizer", "PromptOptimizer"), | |
| "ProviderModelPair": ("effgen.models.router", "ProviderModelPair"), | |
| "ProviderRegistry": ("effgen.models.registry", "ProviderRegistry"), | |
| "ProviderTransientError": ("effgen.models.errors", "ProviderTransientError"), | |
| "RateLimitCoordinator": ("effgen.models._rate_limit", "RateLimitCoordinator"), | |
| "RateLimitExceeded": ("effgen.models._rate_limit", "RateLimitExceeded"), | |
| "RegressionTracker": ("effgen.eval.regression", "RegressionTracker"), | |
| "ReplicateAdapter": ("effgen.models.replicate_adapter", "ReplicateAdapter"), | |
| "ResultAggregator": ("effgen.core.aggregation", "ResultAggregator"), | |
| "RetryPolicy": ("effgen.models.routing.retry", "RetryPolicy"), | |
| "Role": ("effgen.core.messages", "Role"), | |
| "RouterDecision": ("effgen.models.router", "RouterDecision"), | |
| "RouterEvent": ("effgen.models.router", "RouterEvent"), | |
| "RoutingContext": ("effgen.models.router", "RoutingContext"), | |
| "RoutingDecision": ("effgen.core.router", "RoutingDecision"), | |
| "RoutingPolicy": ("effgen.models.router", "RoutingPolicy"), | |
| "RoutingStrategy": ("effgen.core.router", "RoutingStrategy"), | |
| "SLO": ("effgen.observability.slo", "SLO"), | |
| "SLOTracker": ("effgen.observability.slo", "SLOTracker"), | |
| "SQLiteCostStore": ("effgen.models._cost_store", "SQLiteCostStore"), | |
| "SQLiteRateLimitStore": ("effgen.models._rate_limit_store", "SQLiteRateLimitStore"), | |
| "SQLiteStorageBackend": ("effgen.memory.long_term", "SQLiteStorageBackend"), | |
| "SandboxConfig": ("effgen.execution.sandbox", "SandboxConfig"), | |
| "ScienceDomain": ("effgen.domains.presets", "ScienceDomain"), | |
| "ShortTermMemory": ("effgen.memory.short_term", "ShortTermMemory"), | |
| "StreamChunk": ("effgen.models.anthropic_adapter", "StreamChunk"), | |
| "SubAgentRouter": ("effgen.core.router", "SubAgentRouter"), | |
| "SubTask": ("effgen.core.task", "SubTask"), | |
| "SuiteResults": ("effgen.eval.evaluator", "SuiteResults"), | |
| "Task": ("effgen.core.task", "Task"), | |
| "TaskPriority": ("effgen.core.task", "TaskPriority"), | |
| "TaskStatus": ("effgen.core.task", "TaskStatus"), | |
| "TeamConfig": ("effgen.core.orchestrator", "TeamConfig"), | |
| "TeamResponse": ("effgen.core.orchestrator", "TeamResponse"), | |
| "TechDomain": ("effgen.domains.presets", "TechDomain"), | |
| "TemplateManager": ("effgen.prompts.template_manager", "TemplateManager"), | |
| "TestCase": ("effgen.eval.evaluator", "TestCase"), | |
| "TestSuite": ("effgen.eval.suites", "TestSuite"), | |
| "TextPart": ("effgen.core.messages", "TextPart"), | |
| "TogetherAdapter": ("effgen.models.together_adapter", "TogetherAdapter"), | |
| "Tool": ("effgen.tools.function_tool", "Tool"), | |
| "ToolCallPart": ("effgen.core.messages", "ToolCallPart"), | |
| "ToolFallbackChain": ("effgen.tools.fallback", "ToolFallbackChain"), | |
| "ToolIncompatibleError": ("effgen.models.errors", "ToolIncompatibleError"), | |
| "ToolPromptGenerator": ("effgen.prompts.tool_prompt_generator", "ToolPromptGenerator"), | |
| "ToolRegistry": ("effgen.tools.registry", "ToolRegistry"), | |
| "ToolResultPart": ("effgen.core.messages", "ToolResultPart"), | |
| "TransformersEngine": ("effgen.models.transformers_engine", "TransformersEngine"), | |
| "VLLMEngine": ("effgen.models.vllm_engine", "VLLMEngine"), | |
| "ValidationResult": ("effgen.execution.validators", "ValidationResult"), | |
| "ValidationSeverity": ("effgen.execution.validators", "ValidationSeverity"), | |
| "VectorMemoryStore": ("effgen.memory.vector_store", "VectorMemoryStore"), | |
| "VerificationResult": ("effgen.security.supply_chain", "VerificationResult"), | |
| "VideoPart": ("effgen.core.messages", "VideoPart"), | |
| "CheckpointStore": ("effgen.core.workflow_checkpoint", "CheckpointStore"), | |
| "FileCheckpointStore": ("effgen.core.workflow_checkpoint", "FileCheckpointStore"), | |
| "InMemoryCheckpointStore": ( | |
| "effgen.core.workflow_checkpoint", "InMemoryCheckpointStore", | |
| ), | |
| "WorkflowCheckpoint": ("effgen.core.workflow_checkpoint", "WorkflowCheckpoint"), | |
| "WorkflowDAG": ("effgen.core.workflow", "WorkflowDAG"), | |
| "WorkflowEdge": ("effgen.core.workflow", "WorkflowEdge"), | |
| "WorkflowNode": ("effgen.core.workflow", "WorkflowNode"), | |
| "WorkflowResult": ("effgen.core.workflow", "WorkflowResult"), | |
| "audio_from": ("effgen.core.multimodal", "audio_from"), | |
| "cerebras_available_models": ("effgen.models.cerebras_models", "available_models"), | |
| "cerebras_free_tier_models": ("effgen.models.cerebras_models", "free_tier_models"), | |
| "cerebras_model_info": ("effgen.models.cerebras_models", "model_info"), | |
| "check_keys": ("effgen.models.auth", "check_keys"), | |
| "check_slo_and_alert": ("effgen.observability.alerting", "check_slo_and_alert"), | |
| "create_agent": ("effgen.presets.registry", "create_agent"), | |
| "fireworks_available_models": ("effgen.models.fireworks_models", "available_models"), | |
| "fireworks_chat_models": ("effgen.models.fireworks_models", "chat_models"), | |
| "fireworks_pricing_table": ("effgen.models.fireworks_models", "pricing_table"), | |
| "fireworks_refresh_models": ("effgen.models.fireworks_models", "refresh_models"), | |
| "fireworks_tool_capable_models": ("effgen.models.fireworks_models", "tool_capable_models"), | |
| "gemini_available_models": ("effgen.models.gemini_models", "available_models"), | |
| "gemini_free_tier_models": ("effgen.models.gemini_models", "free_tier_models"), | |
| "gemini_model_info": ("effgen.models.gemini_models", "model_info"), | |
| "gemini_recommended_models": ("effgen.models.gemini_models", "recommended_models"), | |
| "get_guardrail_preset": ("effgen.guardrails", "get_guardrail_preset"), | |
| "get_tool_registry": ("effgen.tools.registry", "get_registry"), | |
| "gpu_utils": ("effgen.gpu.utils", None), | |
| "groq_available_models": ("effgen.models.groq_models", "available_models"), | |
| "groq_chat_models": ("effgen.models.groq_models", "chat_models"), | |
| "groq_tool_capable_models": ("effgen.models.groq_models", "tool_capable_models"), | |
| "hf_available_models": ("effgen.models.hf_inference_models", "available_models"), | |
| "hf_catalog_summary": ("effgen.models.hf_inference_models", "catalog_summary"), | |
| "hf_chat_models": ("effgen.models.hf_inference_models", "chat_models"), | |
| "hf_cheapest_provider": ("effgen.models.hf_inference_models", "cheapest_provider"), | |
| "hf_check_drift": ("effgen.models.hf_inference_models", "check_drift"), | |
| "hf_get_model_info": ("effgen.models.hf_inference_models", "get_model_info"), | |
| "hf_list_providers_for": ("effgen.models.hf_inference_models", "list_providers_for"), | |
| "hf_refresh_models": ("effgen.models.hf_inference_models", "refresh_models"), | |
| "hf_serverless_models": ("effgen.models.hf_inference_models", "serverless_models"), | |
| "hf_suggest_alternatives": ("effgen.models.hf_inference_models", "suggest_alternatives"), | |
| "hf_tool_capable_models": ("effgen.models.hf_inference_models", "tool_capable_models"), | |
| "image_from": ("effgen.core.multimodal", "image_from"), | |
| "list_models": ("effgen.models.registry", "list_models"), | |
| "list_presets": ("effgen.presets.registry", "list_presets"), | |
| "list_providers": ("effgen.models.registry", "list_providers"), | |
| "load_env": ("effgen._env", "load_env"), | |
| "load_model": ("effgen.models.model_loader", "load_model"), | |
| "lookup": ("effgen.models.registry", "lookup"), | |
| "openai_available_models": ("effgen.models.openai_models", "available_models"), | |
| "openai_chat_models": ("effgen.models.openai_models", "chat_models"), | |
| "openai_model_info": ("effgen.models.openai_models", "model_info"), | |
| "openai_reasoning_models": ("effgen.models.openai_models", "reasoning_models"), | |
| "replicate_available_models": ("effgen.models.replicate_models", "available_models"), | |
| "replicate_get_model_info": ("effgen.models.replicate_models", "get_model_info"), | |
| "replicate_refresh_models": ("effgen.models.replicate_models", "refresh_models"), | |
| "replicate_streaming_models": ("effgen.models.replicate_models", "streaming_models"), | |
| "replicate_tool_capable_models": ("effgen.models.replicate_models", "tool_capable_models"), | |
| "to_openai_schema": ("effgen.models.openai_schema", "to_openai_schema"), | |
| "tool": ("effgen.tools.function_tool", "tool"), | |
| "together_available_models": ("effgen.models.together_models", "available_models"), | |
| "together_chat_models": ("effgen.models.together_models", "chat_models"), | |
| "together_pricing_table": ("effgen.models.together_models", "pricing_table"), | |
| "together_refresh_models": ("effgen.models.together_models", "refresh_models"), | |
| "together_serverless_models": ("effgen.models.together_models", "serverless_models"), | |
| "together_tool_capable_models": ("effgen.models.together_models", "tool_capable_models"), | |
| "validate_alert_rules_yaml": ("effgen.observability.alerting", "validate_alert_rules_yaml"), | |
| "verify_installed_hashes": ("effgen.security.supply_chain", "verify_installed_hashes"), | |
| "verify_on_startup": ("effgen.security.supply_chain", "verify_on_startup"), | |
| "video_from": ("effgen.core.multimodal", "video_from"), | |
| } | |
| # Guardrail classes share one home; group them so the mapping above stays a flat | |
| # name -> (module, attr) table. | |
| for _name in ( | |
| "Guardrail", | |
| "GuardrailChain", | |
| "GuardrailPosition", | |
| "GuardrailResult", | |
| "LengthGuardrail", | |
| "PIIGuardrail", | |
| "PromptInjectionGuardrail", | |
| "SystemPromptLeakGuardrail", | |
| "ToolInputGuardrail", | |
| "ToolOutputGuardrail", | |
| "ToolPermissionGuardrail", | |
| "TopicGuardrail", | |
| "ToxicityGuardrail", | |
| ): | |
| _LAZY[_name] = ("effgen.guardrails", _name) | |
| del _name | |
| def __getattr__(name: str) -> Any: | |
| """Resolve a public name on first access (PEP 562 lazy import).""" | |
| target = _LAZY.get(name) | |
| if target is None: | |
| raise AttributeError(f"module 'effgen' has no attribute {name!r}") | |
| module_path, attr = target | |
| try: | |
| module = _import_module(module_path) | |
| except ImportError as exc: | |
| # Optional extras (provider-native tools, MLX, eval) may be missing in a | |
| # lean install — surface as a normal missing attribute, not an import | |
| # crash, mirroring the historical try/except import behaviour. | |
| raise AttributeError( | |
| f"module 'effgen' has no attribute {name!r} " | |
| f"(optional component '{module_path}' is not installed: {exc})" | |
| ) from exc | |
| value = module if attr is None else getattr(module, attr) | |
| globals()[name] = value # cache: subsequent access is a plain dict lookup | |
| return value | |
| def __dir__() -> list[str]: | |
| return sorted(set(__all__) | set(_LAZY) | set(globals())) | |
| # The documented public surface. Kept as an explicit literal (not derived from | |
| # ``_LAZY``) so it is greppable and stable; the provider-native/MLX extras in | |
| # ``_LAZY`` are intentionally excluded, matching prior releases. | |
| __all__ = [ | |
| # Pointing effGen at a server, hooks around the loop, and what a run did | |
| "OpenAICompatibleAdapter", | |
| "BackendUnreachableError", | |
| "AgentMiddleware", | |
| "MiddlewareChain", | |
| "LoggingMiddleware", | |
| "ToolApprovalMiddleware", | |
| "ToolCall", | |
| "ToolCallList", | |
| "PartialResult", | |
| "RunStoppedError", | |
| "CompactionStrategy", | |
| "SummarizeOldest", | |
| "DropOldest", | |
| "KeepFirstAndLast", | |
| "KeepToolResults", | |
| # Multimodal message schema | |
| "Role", | |
| "TextPart", | |
| "ImagePart", | |
| "AudioPart", | |
| "VideoPart", | |
| "ToolCallPart", | |
| "ToolResultPart", | |
| "ContentPart", | |
| "MultimodalMessage", | |
| "image_from", | |
| "audio_from", | |
| "video_from", | |
| "CapabilityNotSupportedError", | |
| "InvalidMultimodalContent", | |
| # Core | |
| "Agent", | |
| "AgentConfig", | |
| "Task", | |
| "SubTask", | |
| "TaskStatus", | |
| "TaskPriority", | |
| "AgentState", | |
| # Models | |
| "load_model", | |
| "BaseModel", | |
| "VLLMEngine", | |
| "TransformersEngine", | |
| "OpenAIAdapter", | |
| "AnthropicAdapter", | |
| "StreamChunk", | |
| "GeminiAdapter", | |
| "CerebrasAdapter", | |
| "GroqAdapter", | |
| "TogetherAdapter", | |
| "FireworksAdapter", | |
| "ReplicateAdapter", | |
| "HFInferenceAdapter", | |
| "ModelLoader", | |
| "GenerationConfig", | |
| "GenerationResult", | |
| # Router (v0.2.4+) | |
| "PolicyBasedRouter", | |
| "RoutingPolicy", | |
| "RoutingContext", | |
| "RouterDecision", | |
| "RouterEvent", | |
| "ProviderModelPair", | |
| "FirstAvailablePolicy", | |
| "CostBasedPolicy", | |
| "LatencyBasedPolicy", | |
| "RetryPolicy", | |
| # Tracking (v0.2.4+) | |
| "LatencyTracker", | |
| "CostTracker", | |
| "SQLiteCostStore", | |
| "RateLimitCoordinator", | |
| "RateLimitExceeded", | |
| "SQLiteRateLimitStore", | |
| # Observability — alerting & SLO (v0.3.2+) | |
| "Alert", | |
| "AlertSeverity", | |
| "AlertWebhook", | |
| "check_slo_and_alert", | |
| "validate_alert_rules_yaml", | |
| "SLO", | |
| "SLOTracker", | |
| # Errors | |
| "ModelRefusalError", | |
| "ModelAuthError", | |
| "ModelTimeoutError", | |
| "ModelUnavailableError", | |
| "ModelNotFoundError", | |
| "AmbiguousModelError", | |
| "NoCandidateWithinBudgetError", | |
| "ToolIncompatibleError", | |
| "AllCandidatesExhaustedError", | |
| "BudgetExceededError", | |
| "ProviderTransientError", | |
| "InvalidRequestError", | |
| "to_openai_schema", | |
| # Provider registry + auth | |
| "ProviderRegistry", | |
| "list_providers", | |
| "list_models", | |
| "lookup", | |
| "check_keys", | |
| # Cerebras helpers | |
| "cerebras_available_models", | |
| "cerebras_free_tier_models", | |
| "cerebras_model_info", | |
| # Groq helpers | |
| "groq_available_models", | |
| "groq_chat_models", | |
| "groq_tool_capable_models", | |
| # OpenAI helpers | |
| "openai_available_models", | |
| "openai_chat_models", | |
| "openai_reasoning_models", | |
| "openai_model_info", | |
| # Gemini helpers | |
| "gemini_available_models", | |
| "gemini_free_tier_models", | |
| "gemini_model_info", | |
| "gemini_recommended_models", | |
| # Together helpers | |
| "together_available_models", | |
| "together_chat_models", | |
| "together_tool_capable_models", | |
| "together_pricing_table", | |
| "together_refresh_models", | |
| "together_serverless_models", | |
| # Fireworks helpers | |
| "fireworks_available_models", | |
| "fireworks_chat_models", | |
| "fireworks_tool_capable_models", | |
| "fireworks_pricing_table", | |
| "fireworks_refresh_models", | |
| # Replicate helpers | |
| "replicate_available_models", | |
| "replicate_streaming_models", | |
| "replicate_tool_capable_models", | |
| "replicate_refresh_models", | |
| "replicate_get_model_info", | |
| # HF Inference helpers | |
| "hf_available_models", | |
| "hf_chat_models", | |
| "hf_tool_capable_models", | |
| "hf_serverless_models", | |
| "hf_suggest_alternatives", | |
| "hf_get_model_info", | |
| "hf_refresh_models", | |
| "hf_check_drift", | |
| "hf_catalog_summary", | |
| "hf_list_providers_for", | |
| "hf_cheapest_provider", | |
| # Tools | |
| "BaseTool", | |
| "tool", | |
| "Tool", | |
| "FunctionTool", | |
| "ToolRegistry", | |
| "get_tool_registry", | |
| # Configuration | |
| "ConfigLoader", | |
| "Config", | |
| "ConfigValidator", | |
| # Prompts | |
| "TemplateManager", | |
| "ChainManager", | |
| "PromptOptimizer", | |
| # GPU | |
| "GPUAllocator", | |
| "GPUMonitor", | |
| "gpu_utils", | |
| # Memory | |
| "ShortTermMemory", | |
| "LongTermMemory", | |
| "VectorMemoryStore", | |
| "Message", | |
| "MessageRole", | |
| "MemoryEntry", | |
| "MemoryType", | |
| "ImportanceLevel", | |
| "JSONStorageBackend", | |
| "SQLiteStorageBackend", | |
| # Batch & Aggregation | |
| "BatchRunner", | |
| "BatchConfig", | |
| "BatchResult", | |
| "ResultAggregator", | |
| # Multi-agent orchestration & workflows | |
| "MultiAgentOrchestrator", | |
| "TeamConfig", | |
| "TeamResponse", | |
| "OrchestrationPattern", | |
| "WorkflowDAG", | |
| "WorkflowNode", | |
| "WorkflowEdge", | |
| "WorkflowResult", | |
| "WorkflowCheckpoint", | |
| "CheckpointStore", | |
| "FileCheckpointStore", | |
| "InMemoryCheckpointStore", | |
| "SubAgentRouter", | |
| "RoutingStrategy", | |
| "RoutingDecision", | |
| # Domains | |
| "Domain", | |
| "KeywordExpander", | |
| "TechDomain", | |
| "ScienceDomain", | |
| "FinanceDomain", | |
| "HealthDomain", | |
| "LegalDomain", | |
| # Presets | |
| "create_agent", | |
| "list_presets", | |
| # Environment / keys | |
| "load_env", | |
| # Guardrails (also importable from effgen.guardrails). Listed here so the | |
| # everyday classes are as discoverable at the top level as the domains above. | |
| "Guardrail", | |
| "GuardrailChain", | |
| "GuardrailPosition", | |
| "GuardrailResult", | |
| "PIIGuardrail", | |
| "PromptInjectionGuardrail", | |
| "SystemPromptLeakGuardrail", | |
| "ToxicityGuardrail", | |
| "LengthGuardrail", | |
| "TopicGuardrail", | |
| "ToolInputGuardrail", | |
| "ToolOutputGuardrail", | |
| "ToolPermissionGuardrail", | |
| "get_guardrail_preset", | |
| # Additional convenience exports | |
| "ToolFallbackChain", | |
| "CircuitBreaker", | |
| "ToolPromptGenerator", | |
| "AgentSystemPromptBuilder", | |
| # Eval | |
| "AgentEvaluator", | |
| "EvalResult", | |
| "SuiteResults", | |
| "TestCase", | |
| "TestSuite", | |
| "ModelComparison", | |
| "RegressionTracker", | |
| # Execution | |
| "CodeExecutor", | |
| "ExecutionResult", | |
| "ExecutionStatus", | |
| "CodeValidator", | |
| "ValidationResult", | |
| "ValidationSeverity", | |
| "SandboxConfig", | |
| # Security | |
| "HashDriftWarning", | |
| "VerificationResult", | |
| "verify_installed_hashes", | |
| "verify_on_startup", | |
| ] | |
| if TYPE_CHECKING: | |
| # Make the lazy names visible to type checkers and IDEs without paying the | |
| # import cost at runtime. | |
| from effgen.config import Config, ConfigLoader, ConfigValidator | |
| from effgen.core.agent import Agent, AgentConfig | |
| from effgen.models import BaseModel, load_model | |
| from effgen.tools import BaseTool | |
| # Supply-chain integrity check — runs only when EFFGEN_VERIFY_HASHES=1. The | |
| # env-var gate is replicated here so a normal `import effgen` never imports the | |
| # security module (keeping startup cheap); behaviour is unchanged when opted in. | |
| if _os.environ.get("EFFGEN_VERIFY_HASHES", "0") == "1": | |
| from effgen.security.supply_chain import verify_on_startup as _verify_on_startup | |
| _verify_on_startup() | |
Xet Storage Details
- Size:
- 28.7 kB
- Xet hash:
- 27a8c7e1b96660bb12c450cdad02f372708e7fb1ac3d138e9b665ef2fa15cbc7
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.