{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-composio-core","slug":"pypi-composio-core","name":"composio-core","type":"repo","url":"https://github.com/composiohq/composio","page_url":"https://unfragile.ai/pypi-composio-core","categories":["frameworks-sdks"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-composio-core__cap_0","uri":"capability://tool.use.integration.llm.to.external.service.action.bridging.via.unified.api.schema","name":"llm-to-external-service action bridging via unified api schema","description":"Composio acts as an abstraction layer that translates LLM function calls into standardized API requests to external services (SaaS platforms, internal APIs, webhooks). It uses a schema registry pattern where each integrated service's capabilities are mapped to a canonical action definition, allowing LLMs to invoke third-party tools without direct knowledge of their underlying API contracts. The bridge handles authentication token management, request/response transformation, and error handling across heterogeneous service types.","intents":["I want my LLM agent to trigger actions in Slack, Gmail, Salesforce, or other SaaS tools without writing custom API integration code","I need to abstract away API authentication and versioning differences so my agent can work with multiple service providers interchangeably","I want to give my LLM agent the ability to perform real-world tasks like sending emails, creating tickets, or updating spreadsheets"],"best_for":["AI agent developers building multi-tool orchestration workflows","Teams building LLM-powered automation platforms that need to integrate 50+ SaaS tools","Developers wanting to reduce boilerplate for LLM function-calling integrations"],"limitations":["Deprecated in favor of main 'composio' package — this core package no longer receives updates","Requires pre-built action definitions for each service; custom service integration requires extending the action registry","Latency overhead from schema translation and authentication token refresh on each action invocation","Limited to services with REST/webhook APIs; GraphQL or streaming APIs require custom adapters"],"requires":["Python 3.8+","API credentials for target services (OAuth tokens, API keys, or webhook URLs)","composio package (main package) as the replacement for this deprecated core"],"input_types":["LLM function call with parameters matching action schema","Service API credentials (OAuth tokens, API keys)","Structured action parameters (strings, numbers, booleans, arrays)"],"output_types":["Structured API response (JSON)","Success/failure status with error details","Service-specific response data (email IDs, ticket numbers, etc.)"],"categories":["tool-use-integration","api-orchestration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-composio-core__cap_1","uri":"capability://tool.use.integration.multi.provider.llm.function.calling.adapter.with.schema.normalization","name":"multi-provider llm function-calling adapter with schema normalization","description":"Composio-core provides a unified interface for function calling across different LLM providers (OpenAI, Anthropic, Ollama, etc.) by normalizing their function-calling schemas into a canonical format. It translates between provider-specific function definition formats (OpenAI's tools, Anthropic's tool_use, etc.) and Composio's internal action schema, allowing the same action definitions to work across multiple LLM backends without code changes. This abstraction handles schema validation, parameter mapping, and response parsing for each provider's specific function-calling protocol.","intents":["I want to switch between OpenAI, Anthropic, and open-source LLMs without rewriting my function-calling logic","I need to define actions once and have them work with any LLM provider's function-calling API","I want to abstract away provider-specific function schema differences so my agent code is portable"],"best_for":["Multi-model AI teams that want to experiment with different LLM providers without refactoring","Developers building LLM applications that need to support customer choice of model provider","Organizations evaluating cost/performance tradeoffs across OpenAI, Anthropic, and open-source models"],"limitations":["Deprecated package — use main 'composio' package for active support","Schema normalization adds ~50-100ms overhead per function call due to translation layer","Some provider-specific function-calling features (e.g., parallel tool calls in OpenAI) may not be fully exposed through the abstraction","Requires explicit provider configuration; no automatic provider selection based on model capabilities"],"requires":["Python 3.8+","API key for at least one supported LLM provider (OpenAI, Anthropic, Ollama, etc.)","composio main package (recommended replacement)"],"input_types":["Composio action schema definition (JSON)","LLM provider identifier (string: 'openai', 'anthropic', 'ollama')","LLM response with function calls in provider-specific format"],"output_types":["Normalized function call representation","Mapped parameters matching action schema","Provider-agnostic execution result"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-composio-core__cap_2","uri":"capability://tool.use.integration.stateless.action.execution.with.credential.management.and.token.refresh","name":"stateless action execution with credential management and token refresh","description":"Composio-core manages the execution lifecycle of actions by handling credential storage, OAuth token refresh, and request/response transformation without maintaining persistent state. Each action execution is independent; credentials are retrieved from a credential store (environment variables, secure vault, or platform-managed), tokens are refreshed on-demand before API calls, and responses are normalized before returning to the LLM. This stateless design enables horizontal scaling and simplifies deployment in serverless or containerized environments.","intents":["I want my agent to automatically refresh OAuth tokens before making API calls without manual intervention","I need to securely manage API credentials for multiple services without hardcoding them in my agent code","I want action execution to be stateless so I can scale my agent horizontally across multiple workers"],"best_for":["Developers deploying agents in serverless environments (AWS Lambda, Google Cloud Functions)","Teams managing credentials for multiple users/tenants across a multi-tenant agent platform","Organizations requiring audit trails and credential rotation without agent downtime"],"limitations":["No built-in credential persistence — requires external credential store (environment, vault, or platform)","Token refresh adds latency on first action call after token expiration (typically 500ms-2s)","Stateless design means no in-memory caching of credentials; each action invocation may require credential lookup","Limited support for complex credential flows (e.g., mutual TLS, certificate rotation)"],"requires":["Python 3.8+","Credential store configured (environment variables, HashiCorp Vault, AWS Secrets Manager, or Composio platform)","Service API credentials with appropriate scopes for target actions"],"input_types":["Action name and parameters","User/tenant identifier for credential lookup","Service-specific credential identifiers"],"output_types":["Execution status (success/failure)","Normalized API response","Error details with retry guidance"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-composio-core__cap_3","uri":"capability://memory.knowledge.action.schema.registry.with.dynamic.capability.discovery","name":"action schema registry with dynamic capability discovery","description":"Composio-core maintains a registry of pre-defined action schemas for 50+ integrated services, allowing agents to dynamically discover available capabilities without hardcoding action definitions. The registry includes metadata for each action (name, description, parameters, required scopes) and supports runtime queries to list available actions for a given service or filter by capability type. This enables agents to introspect available tools and make decisions about which actions to invoke based on the current task.","intents":["I want my agent to discover what actions are available for a service (e.g., all Slack actions) without hardcoding a list","I need to filter available actions by required permissions or authentication scopes","I want to generate LLM prompts that describe available actions dynamically based on the registry"],"best_for":["Developers building flexible agents that adapt to available integrations at runtime","Teams managing large action libraries and needing centralized schema definitions","Platforms providing agent-building interfaces where users select from available actions"],"limitations":["Deprecated package — registry is now maintained in the main 'composio' package","Registry is static at runtime; adding new actions requires package update or custom extension","No built-in versioning for action schemas; breaking changes to action parameters require careful migration","Registry lookup adds ~10-50ms latency per query; not suitable for real-time action filtering in latency-critical paths"],"requires":["Python 3.8+","composio-core package with pre-built action definitions","composio main package (recommended for updated registry)"],"input_types":["Service name (string: 'slack', 'gmail', 'salesforce', etc.)","Filter criteria (capability type, required scopes, action name pattern)"],"output_types":["List of action schemas (JSON)","Action metadata (name, description, parameters, required scopes)","LLM-friendly action descriptions"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-composio-core__cap_4","uri":"capability://automation.workflow.error.handling.and.retry.logic.with.service.specific.fallbacks","name":"error handling and retry logic with service-specific fallbacks","description":"Composio-core implements a retry mechanism with exponential backoff for failed action executions, with service-specific handling for common error types (rate limits, authentication failures, transient errors). When an action fails, the framework classifies the error (retryable vs. permanent) and applies appropriate retry strategies; for example, rate-limit errors trigger exponential backoff, while authentication failures trigger token refresh and retry. This reduces the need for agents to implement custom error handling for each service.","intents":["I want my agent to automatically retry failed API calls with exponential backoff instead of failing immediately","I need to handle rate limits gracefully by backing off and retrying rather than crashing","I want authentication failures to trigger token refresh and automatic retry without agent intervention"],"best_for":["Agents making calls to rate-limited APIs (Slack, Gmail, etc.)","Multi-step workflows where transient failures should be retried automatically","Teams wanting to reduce boilerplate error handling in agent code"],"limitations":["Deprecated package — error handling is now in main 'composio' package","Retry logic is not configurable per action; uses global retry policy","Exponential backoff can add significant latency for heavily rate-limited services (up to 60+ seconds for max retries)","No built-in circuit breaker pattern; repeated failures don't prevent subsequent attempts"],"requires":["Python 3.8+","composio-core package","composio main package (recommended for enhanced error handling)"],"input_types":["Action execution request","Service API response (success or error)"],"output_types":["Retry decision (retry, fail, or skip)","Error classification (retryable, rate-limited, auth failure, permanent)","Normalized error message for agent consumption"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-composio-core__cap_5","uri":"capability://data.processing.analysis.response.normalization.and.data.transformation.across.heterogeneous.apis","name":"response normalization and data transformation across heterogeneous apis","description":"Composio-core normalizes API responses from different services into a consistent format before returning them to the LLM, handling differences in response structure, data types, and field naming conventions. For example, Slack's API returns user IDs in one format while Gmail returns them differently; Composio normalizes both to a canonical user representation. This transformation layer includes field mapping, type coercion, and filtering to extract relevant data, reducing the cognitive load on agents when working with multiple services.","intents":["I want API responses from different services to have consistent field names and structures so my agent doesn't need service-specific parsing logic","I need to extract only relevant fields from API responses to reduce token consumption in LLM prompts","I want to handle differences in data types across services (e.g., timestamps in different formats) transparently"],"best_for":["Multi-service agents that need to work with responses from 10+ different APIs","Teams wanting to reduce agent prompt complexity by normalizing response formats","Developers building agent frameworks that abstract service-specific response handling"],"limitations":["Deprecated package — response normalization is now in main 'composio' package","Normalization rules are pre-defined; custom transformations require extending the framework","Filtering relevant fields may lose context that the agent needs for complex tasks","Transformation adds ~20-50ms latency per response"],"requires":["Python 3.8+","composio-core package with pre-defined response schemas","composio main package (recommended)"],"input_types":["Raw API response (JSON)","Service identifier (string: 'slack', 'gmail', etc.)","Action name for context-specific transformation"],"output_types":["Normalized response (JSON with consistent field names and types)","Filtered/extracted relevant data","LLM-friendly response format"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-composio-core__cap_6","uri":"capability://tool.use.integration.composio.platform.integration.with.cloud.hosted.action.execution","name":"composio platform integration with cloud-hosted action execution","description":"Composio-core acts as a client library for the Composio platform, enabling agents to execute actions on cloud-hosted infrastructure managed by Composio. Instead of executing actions locally, the core package sends action requests to the Composio platform API, which handles credential management, service integration, and execution. This allows agents to leverage Composio's managed infrastructure without maintaining their own integration code, and enables features like audit logging, usage analytics, and centralized credential management.","intents":["I want to execute actions on Composio's managed platform instead of managing integrations myself","I need centralized credential management and audit logging for all agent actions","I want to leverage Composio's pre-built integrations without hosting my own integration code"],"best_for":["Teams using Composio's managed platform for agent hosting","Organizations wanting to outsource integration management to Composio","Developers building agents that need audit logging and usage analytics"],"limitations":["Deprecated package — use main 'composio' package for platform integration","Requires Composio platform account and API key","Network latency for cloud-hosted execution (typically 200-500ms per action)","Vendor lock-in to Composio platform; migrating to self-hosted execution requires code changes","Platform rate limits may restrict action execution frequency"],"requires":["Python 3.8+","Composio platform account and API key","Network connectivity to Composio API endpoints","composio main package (recommended)"],"input_types":["Action name and parameters","Composio API key for authentication","User/tenant identifier for platform-managed credentials"],"output_types":["Action execution result from Composio platform","Execution metadata (timestamp, duration, status)","Audit log entry (if enabled)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":25,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","API credentials for target services (OAuth tokens, API keys, or webhook URLs)","composio package (main package) as the replacement for this deprecated core","API key for at least one supported LLM provider (OpenAI, Anthropic, Ollama, etc.)","composio main package (recommended replacement)","Credential store configured (environment variables, HashiCorp Vault, AWS Secrets Manager, or Composio platform)","Service API credentials with appropriate scopes for target actions","composio-core package with pre-built action definitions","composio main package (recommended for updated registry)","composio-core package"],"failure_modes":["Deprecated in favor of main 'composio' package — this core package no longer receives updates","Requires pre-built action definitions for each service; custom service integration requires extending the action registry","Latency overhead from schema translation and authentication token refresh on each action invocation","Limited to services with REST/webhook APIs; GraphQL or streaming APIs require custom adapters","Deprecated package — use main 'composio' package for active support","Schema normalization adds ~50-100ms overhead per function call due to translation layer","Some provider-specific function-calling features (e.g., parallel tool calls in OpenAI) may not be fully exposed through the abstraction","Requires explicit provider configuration; no automatic provider selection based on model capabilities","No built-in credential persistence — requires external credential store (environment, vault, or platform)","Token refresh adds latency on first action call after token expiration (typically 500ms-2s)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.39,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:05.295Z","last_scraped_at":"2026-05-03T15:20:21.281Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-composio-core","compare_url":"https://unfragile.ai/compare?artifact=pypi-composio-core"}},"signature":"s3cVqE8Z+kD1dqz6GHOZIAkfKqHmXORO9eu0X5vygEb43DZAUMLpUeWBivvUXBZL+0v47hIWL+FwaXPipkXaDQ==","signedAt":"2026-06-21T06:33:18.070Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-composio-core","artifact":"https://unfragile.ai/pypi-composio-core","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-composio-core","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}