{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-coze-dev--coze-studio","slug":"coze-dev--coze-studio","name":"coze-studio","type":"agent","url":"https://github.com/coze-dev/coze-studio","page_url":"https://unfragile.ai/coze-dev--coze-studio","categories":["app-builders"],"tags":["agent","agent-platform","ai-plugins","chatbot","chatbot-framework","coze","coze-platform","generative-ai","go","kouzi","low-code-ai","multimodel-ai","no-code","rag","studio","typescript","workflow"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-coze-dev--coze-studio__cap_0","uri":"capability://planning.reasoning.visual.agent.orchestration.with.rag.and.workflow.integration","name":"visual agent orchestration with rag and workflow integration","description":"Provides a React 18-based visual canvas IDE for composing conversational AI agents by connecting LLM models, RAG knowledge bases, plugins, and workflow nodes without code. Uses a FlowGram engine to render and manage directed acyclic graphs of agent logic, with Zustand state management for real-time canvas synchronization and a Thrift IDL layer enforcing strict type contracts between frontend and Go backend services that execute the composed workflows.","intents":["I want to build a multi-step agent that retrieves documents, processes them, and responds without writing code","I need to visually debug agent behavior by stepping through workflow execution and inspecting intermediate states","I want to reuse agent components across multiple projects and share them with my team"],"best_for":["non-technical product managers and business analysts building AI workflows","teams migrating from REST API orchestration to agentic patterns","enterprises requiring visual auditability of AI decision logic"],"limitations":["FlowGram canvas performance degrades with >100 nodes due to React re-render overhead; requires node clustering or lazy evaluation for large workflows","Thrift IDL contract enforcement adds ~50ms serialization latency per RPC call between frontend and backend","Visual debugging limited to sequential workflows; parallel branching and conditional loops require manual state inspection"],"requires":["Node.js 18+ for frontend development","Go 1.24+ for backend services","Docker and Docker Compose for local deployment","At least one LLM provider API key (OpenAI, Volcengine, or compatible)"],"input_types":["visual node definitions (JSON-serialized via Thrift)","LLM model configurations","RAG knowledge base references","plugin/tool definitions"],"output_types":["executable agent workflow DAG","agent deployment manifest","chat session logs with intermediate execution traces"],"categories":["planning-reasoning","automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_1","uri":"capability://tool.use.integration.multi.provider.llm.model.service.management.and.routing","name":"multi-provider llm model service management and routing","description":"Abstracts LLM provider APIs (OpenAI, Volcengine, and others) through a unified model service layer that manages model lists, credentials, and request routing. The backend uses Go's Hertz HTTP framework with domain-driven service handlers that normalize provider-specific request/response formats into a common interface, allowing agents to switch models or providers without workflow changes.","intents":["I want to test my agent with different LLM providers without rewriting prompts or logic","I need to route requests to cheaper models for simple tasks and premium models for complex reasoning","I want to manage API keys and quotas centrally across all agents in my organization"],"best_for":["teams evaluating multiple LLM providers for cost/performance tradeoffs","enterprises with multi-cloud or multi-vendor requirements","developers building LLM applications that need provider abstraction"],"limitations":["Provider-specific features (e.g., OpenAI's vision, Volcengine's custom parameters) require custom adapter code; no automatic feature parity","Model list synchronization is manual or polling-based; no real-time provider API change detection","Routing logic is configuration-driven; no built-in cost optimization or latency-based failover without custom middleware"],"requires":["Go 1.24+ backend runtime","API keys for at least one LLM provider","MySQL 8.4.5+ for model metadata storage","Redis for credential caching (optional but recommended)"],"input_types":["model configuration objects (name, provider, parameters)","chat completion requests with provider-agnostic schema","credential/API key objects"],"output_types":["normalized LLM responses","model availability status","usage metrics and cost logs"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_10","uri":"capability://tool.use.integration.openapi.and.chat.sdk.for.agent.integration.and.deployment","name":"openapi and chat sdk for agent integration and deployment","description":"Exposes agent functionality through OpenAPI endpoints for chat session management and a Chat SDK (TypeScript/Python) for application integration. The OpenAPI spec is auto-generated from Thrift IDL, providing standard REST endpoints for creating sessions, sending messages, and retrieving traces. The Chat SDK wraps these endpoints with convenience methods, error handling, and streaming support for real-time agent responses.","intents":["I want to embed a Coze agent in my web application without building a custom chat UI","I need to integrate agent responses into my backend service or workflow","I want to stream agent responses to the client in real-time for better UX"],"best_for":["developers integrating Coze agents into existing applications","teams building multi-channel chatbot deployments (web, mobile, Slack)","organizations requiring programmatic agent access without the Coze Studio UI"],"limitations":["OpenAPI endpoints are synchronous; long-running agents (>30s) require polling or async patterns","Chat SDK is TypeScript/Python only; no Go, Java, or other language bindings","Streaming support requires WebSocket upgrade; standard HTTP polling is slower","No built-in rate limiting or quota enforcement; requires external API gateway"],"requires":["OpenAPI client library (auto-generated or manual)","Chat SDK (TypeScript or Python)","Agent deployment URL and API key"],"input_types":["user messages (text, optional attachments)","session configuration (agent ID, model, parameters)","streaming preferences (polling vs WebSocket)"],"output_types":["agent responses (text, structured data)","session metadata (ID, created_at, updated_at)","execution traces (optional, for debugging)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_11","uri":"capability://automation.workflow.infrastructure.as.code.deployment.with.docker.kubernetes.and.helm","name":"infrastructure-as-code deployment with docker, kubernetes, and helm","description":"Provides Docker Compose configurations for local development and Kubernetes Helm charts for production deployment. The Docker Compose setup includes all services (frontend, backend, MySQL, Redis, Elasticsearch, vector databases) with environment variable configuration. Helm charts abstract Kubernetes resources (Deployments, Services, ConfigMaps, Secrets) and enable parameterized multi-environment deployments (staging, production) with different resource limits and replica counts.","intents":["I want to deploy Coze Studio to production on Kubernetes without writing YAML","I need to manage different configurations for staging and production environments","I want to scale agent services independently based on traffic"],"best_for":["teams deploying Coze Studio on-premises or in private clouds","organizations with Kubernetes infrastructure and Helm expertise","enterprises requiring custom infrastructure integrations (private registries, custom networking)"],"limitations":["Helm charts are Kubernetes-specific; no support for Docker Swarm, Nomad, or other orchestrators","Multi-environment configuration requires separate values files; no built-in templating for complex scenarios","Database migrations are manual; no automated schema versioning or rollback","Persistent volume configuration is environment-specific; no built-in backup or disaster recovery"],"requires":["Docker and Docker Compose for local development","Kubernetes 1.20+ cluster for production","Helm 3.0+ for chart deployment","kubectl CLI for cluster management","Persistent storage (PVC) for databases"],"input_types":["Docker Compose files (.yml)","Helm values files (values.yaml, values-staging.yaml, values-prod.yaml)","environment variables (.env files)"],"output_types":["running Coze Studio deployment","Kubernetes resources (Deployments, Services, ConfigMaps)","deployment logs and status"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_2","uri":"capability://memory.knowledge.rag.knowledge.base.indexing.retrieval.and.semantic.search","name":"rag knowledge base indexing, retrieval, and semantic search","description":"Provides a resource management system for uploading, indexing, and retrieving documents through a RAG pipeline built on the Eino framework. Documents are embedded using configurable vector models, stored in vector databases (Milvus, OceanBase, or similar), and retrieved via semantic search with BM25 hybrid ranking. The backend Go services handle chunking, embedding, and retrieval orchestration, while the frontend provides UI for knowledge base CRUD and search testing.","intents":["I want to upload company documentation and have agents automatically retrieve relevant context for customer queries","I need to test RAG retrieval quality before deploying agents to production","I want to manage multiple knowledge bases and control which agents can access which documents"],"best_for":["enterprises building customer support or internal knowledge chatbots","teams with large document repositories requiring semantic search","organizations needing fine-grained access control over knowledge bases"],"limitations":["Chunking strategy is fixed (no dynamic chunk size optimization); large documents may require manual pre-processing","Vector database selection is deployment-time configuration; switching databases requires data re-indexing","Retrieval latency depends on vector DB performance; Milvus on single node can handle ~1M documents before degradation","No built-in document versioning or update tracking; full re-indexing required for document changes"],"requires":["Go 1.24+ backend","Vector database (Milvus, OceanBase, or compatible)","Elasticsearch for BM25 hybrid search (optional but recommended)","Embedding model API (OpenAI, Volcengine, or local)","MySQL 8.4.5+ for metadata storage"],"input_types":["documents (PDF, TXT, Markdown, HTML)","document metadata (title, source, tags)","semantic search queries","retrieval configuration (top-k, similarity threshold)"],"output_types":["ranked document chunks with similarity scores","retrieval metrics (precision, recall, latency)","knowledge base statistics (document count, index size)"],"categories":["memory-knowledge","search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_3","uri":"capability://tool.use.integration.plugin.and.tool.integration.with.schema.based.function.calling","name":"plugin and tool integration with schema-based function calling","description":"Enables agents to invoke external tools and APIs through a plugin registry system where each plugin defines a Thrift-based schema specifying inputs, outputs, and execution logic. The backend maintains a plugin service that validates requests against schemas, handles authentication/credentials, and orchestrates execution via HTTP or gRPC. Plugins can be built as standalone services or embedded Go modules, and the frontend provides UI for plugin discovery, configuration, and testing.","intents":["I want my agent to call external APIs (Slack, Salesforce, databases) without hardcoding credentials","I need to validate tool inputs before execution and handle errors gracefully","I want to build custom tools specific to my business logic and reuse them across agents"],"best_for":["teams building enterprise agents that integrate with SaaS platforms","developers creating custom business logic tools","organizations requiring audit trails and permission controls for tool execution"],"limitations":["Plugin schema validation is synchronous; no async schema evolution or backward compatibility checks","Credential management is centralized in backend; no per-user or per-agent credential isolation without custom middleware","Plugin execution timeout is fixed; long-running tools (>30s) require async patterns or external job queues","No built-in rate limiting or quota management per plugin; requires external API gateway"],"requires":["Go 1.24+ for plugin service","Thrift IDL compiler for schema definition","HTTP or gRPC endpoint for plugin execution","Credential storage (environment variables, secret manager, or Redis)"],"input_types":["plugin schema definitions (Thrift IDL)","tool invocation requests with validated parameters","credential objects (API keys, OAuth tokens)"],"output_types":["tool execution results (JSON, structured data)","execution logs and error traces","plugin availability and health status"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_4","uri":"capability://automation.workflow.agent.lifecycle.management.with.versioning.publishing.and.deployment","name":"agent lifecycle management with versioning, publishing, and deployment","description":"Manages the complete agent lifecycle from creation through deployment, including version control, publishing to registries, and deployment to production environments. The backend stores agent definitions (prompts, workflows, RAG bindings, plugins) in MySQL, tracks version history, and provides APIs for publishing agents as immutable releases. The frontend IDE includes publish workflows, deployment configuration UI, and agent marketplace browsing for discovering and importing published agents.","intents":["I want to version my agent and roll back to previous versions if a deployment breaks","I need to publish my agent so other teams can discover and reuse it","I want to deploy the same agent to multiple environments (staging, production) with different configurations"],"best_for":["teams managing multiple agents across environments","organizations with agent reuse and sharing requirements","enterprises needing audit trails and change tracking for AI systems"],"limitations":["Version control is agent-level only; no fine-grained versioning of individual components (prompts, workflows) within an agent","Publishing is manual; no CI/CD integration for automated testing and deployment","Deployment configuration is environment-specific; no templating or parameterization for multi-environment setups","Agent marketplace is centralized; no federated or private registry support"],"requires":["Go 1.24+ backend with MySQL 8.4.5+","API key for publishing (if using central registry)","Deployment target (Docker, Kubernetes, or serverless platform)"],"input_types":["agent definition (prompts, workflows, RAG, plugins)","version metadata (description, changelog)","deployment configuration (environment variables, resource limits)"],"output_types":["published agent manifest","deployment status and logs","version history and diff reports"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_5","uri":"capability://automation.workflow.real.time.chat.session.management.with.execution.tracing","name":"real-time chat session management with execution tracing","description":"Manages chat sessions between users and deployed agents, capturing full execution traces including LLM calls, tool invocations, RAG retrievals, and workflow steps. Sessions are stored in MySQL with Redis caching for active sessions, and the backend exposes OpenAPI endpoints for session creation, message sending, and trace retrieval. The frontend provides a chat UI with side-by-side execution trace visualization, allowing developers to inspect intermediate states and debug agent behavior.","intents":["I want to see exactly what my agent is doing at each step when it responds to a user query","I need to debug why an agent gave an incorrect answer by inspecting the LLM prompt and RAG retrieval","I want to analyze agent performance metrics (latency, token usage, tool success rate) across sessions"],"best_for":["developers debugging agent behavior in development and staging","teams analyzing agent performance and user satisfaction metrics","enterprises requiring audit trails for compliance (financial, healthcare)"],"limitations":["Trace storage grows linearly with session count; no automatic pruning or archival to cold storage","Real-time trace streaming uses polling; no WebSocket support for sub-second latency updates","Trace visualization is limited to sequential workflows; parallel execution branches require manual inspection","Token usage and cost tracking is approximate; no real-time billing integration"],"requires":["Go 1.24+ backend with MySQL 8.4.5+ and Redis","OpenAPI client for session management","Chat SDK for application integration (provided)"],"input_types":["user messages (text, optional attachments)","session configuration (agent ID, model, parameters)","trace filtering criteria (tool type, latency threshold)"],"output_types":["agent responses (text, structured data)","execution traces (JSON with nested LLM calls, tool invocations, RAG retrievals)","session metrics (latency, token count, cost)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_6","uri":"capability://planning.reasoning.workflow.visual.editor.with.conditional.logic.and.looping","name":"workflow visual editor with conditional logic and looping","description":"Provides a visual canvas for designing complex agent workflows with nodes for LLM calls, tool invocations, RAG retrievals, and control flow (conditionals, loops). The FlowGram engine renders the workflow as a directed acyclic graph (DAG) with drag-and-drop node composition, and the backend interprets the workflow definition to execute steps sequentially or in parallel. Workflows support variable binding, expression evaluation, and error handling with fallback paths.","intents":["I want to build a multi-step workflow where the agent decides which tool to call based on the user's intent","I need to loop through a list of items and process each one with the agent","I want to handle errors gracefully by retrying failed steps or executing fallback logic"],"best_for":["business analysts designing complex agent logic without code","teams building workflows that require conditional branching or iteration","organizations needing visual documentation of agent decision logic"],"limitations":["DAG constraint prevents cycles; workflows must be acyclic (no true loops, only iteration over collections)","Expression evaluation is limited to simple comparisons and variable substitution; no complex Python/JavaScript expressions","Parallel execution requires explicit node configuration; no automatic parallelization of independent branches","Workflow debugging is limited to step-by-step execution; no breakpoints or conditional breakpoints"],"requires":["React 18+ frontend with Zustand state management","Go 1.24+ backend with Eino workflow orchestration","FlowGram engine (included in monorepo)"],"input_types":["workflow node definitions (type, parameters, connections)","variable bindings and expressions","error handling configuration (retry policy, fallback path)"],"output_types":["executable workflow DAG","workflow execution logs with step-by-step traces","workflow performance metrics (latency per step, success rate)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_7","uri":"capability://automation.workflow.monorepo.based.development.environment.with.rush.js.and.docker.compose","name":"monorepo-based development environment with rush.js and docker compose","description":"Provides a unified development environment using Rush.js for TypeScript/React frontend package management and Docker Compose for local backend/infrastructure deployment. The monorepo separates frontend IDEs (Agent IDE, Studio, Project IDE), backend services (API handlers, domain services), and shared infrastructure (MySQL, Redis, Elasticsearch, vector databases). Developers can run the entire stack locally with a single `make web` command, with hot-reload for frontend changes and automatic backend service restart on code changes.","intents":["I want to set up a local development environment for Coze Studio without complex infrastructure knowledge","I need to contribute to both frontend and backend without managing separate repositories","I want to test my agent changes against the full stack before pushing to production"],"best_for":["developers contributing to Coze Studio open-source project","teams deploying Coze Studio on-premises with Docker/Kubernetes","organizations building custom extensions on top of Coze Studio"],"limitations":["Docker Compose is single-node; no built-in clustering or high-availability for local development","Rush.js monorepo management adds complexity for developers unfamiliar with workspace tools; requires understanding of rush.json and package dependencies","Hot-reload works for frontend; backend changes require manual service restart or Docker container rebuild (~30s)","Local development requires 8GB+ RAM and 20GB+ disk space for all services and dependencies"],"requires":["Docker and Docker Compose (latest versions)","Node.js 18+ and npm/yarn for frontend development","Go 1.24+ for backend development","Make or equivalent build tool","Git for version control"],"input_types":["source code changes (TypeScript, Go)","environment configuration (.env files)","Docker Compose overrides (docker-compose.override.yml)"],"output_types":["running local development stack","frontend hot-reload updates","backend service logs and traces"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_8","uri":"capability://tool.use.integration.thrift.based.interface.definition.layer.with.strict.type.contracts","name":"thrift-based interface definition layer with strict type contracts","description":"Defines all frontend-backend communication through Thrift IDL files, ensuring strict type safety and contract enforcement across the monorepo. The Thrift compiler generates TypeScript types for the frontend and Go structs for the backend, preventing runtime type mismatches and enabling automatic API documentation. Changes to IDL files trigger validation in CI/CD pipelines, and breaking changes are flagged before merge.","intents":["I want to ensure frontend and backend stay in sync when I change an API contract","I need to generate API documentation automatically from type definitions","I want to catch breaking API changes in code review before they reach production"],"best_for":["teams with strict API contract requirements","organizations prioritizing type safety over development speed","projects with separate frontend and backend teams"],"limitations":["Thrift IDL adds ~50ms serialization overhead per RPC call compared to JSON","Thrift schema evolution requires careful versioning; no automatic backward compatibility","Developers must understand Thrift syntax and type system; steeper learning curve than JSON Schema","Thrift tooling is less mature than Protocol Buffers; fewer language bindings and IDE integrations"],"requires":["Thrift compiler (0.16+)","TypeScript and Go code generation plugins","CI/CD pipeline with IDL validation step"],"input_types":["Thrift IDL files (.thrift)","service definitions (RPC methods, data structures)"],"output_types":["generated TypeScript types","generated Go structs and service interfaces","API documentation (optional)"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-coze-dev--coze-studio__cap_9","uri":"capability://automation.workflow.domain.driven.design.backend.architecture.with.service.layer.abstraction","name":"domain-driven design backend architecture with service layer abstraction","description":"Organizes backend services using Domain-Driven Design (DDD) principles with clear separation between API handlers, domain services, and infrastructure adapters. Each domain (agents, workflows, RAG, plugins) has its own service layer that encapsulates business logic, with infrastructure adapters for databases, caches, and external APIs. The Hertz HTTP framework routes requests to handlers that delegate to domain services, ensuring business logic is decoupled from HTTP concerns.","intents":["I want to add a new feature (e.g., agent versioning) without touching existing code","I need to test business logic independently of HTTP and database layers","I want to understand the codebase structure and find where a feature is implemented"],"best_for":["teams building complex backend systems with multiple domains","organizations prioritizing code maintainability and testability","projects with long-term maintenance requirements"],"limitations":["DDD adds architectural overhead; simple CRUD operations require more boilerplate than monolithic approaches","Service layer abstraction adds ~10-20ms latency per request due to additional function calls","Requires discipline to maintain domain boundaries; easy to create circular dependencies if not careful","Testing domain services requires mocking infrastructure adapters; no built-in test fixtures"],"requires":["Go 1.24+ with understanding of DDD patterns","Hertz HTTP framework","MySQL 8.4.5+ for persistence","Redis for caching (optional)"],"input_types":["HTTP requests (routed by Hertz handlers)","domain commands and queries"],"output_types":["domain entities and value objects","HTTP responses (serialized via Thrift)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":53,"verified":false,"data_access_risk":"high","permissions":["Node.js 18+ for frontend development","Go 1.24+ for backend services","Docker and Docker Compose for local deployment","At least one LLM provider API key (OpenAI, Volcengine, or compatible)","Go 1.24+ backend runtime","API keys for at least one LLM provider","MySQL 8.4.5+ for model metadata storage","Redis for credential caching (optional but recommended)","OpenAPI client library (auto-generated or manual)","Chat SDK (TypeScript or Python)"],"failure_modes":["FlowGram canvas performance degrades with >100 nodes due to React re-render overhead; requires node clustering or lazy evaluation for large workflows","Thrift IDL contract enforcement adds ~50ms serialization latency per RPC call between frontend and backend","Visual debugging limited to sequential workflows; parallel branching and conditional loops require manual state inspection","Provider-specific features (e.g., OpenAI's vision, Volcengine's custom parameters) require custom adapter code; no automatic feature parity","Model list synchronization is manual or polling-based; no real-time provider API change detection","Routing logic is configuration-driven; no built-in cost optimization or latency-based failover without custom middleware","OpenAPI endpoints are synchronous; long-running agents (>30s) require polling or async patterns","Chat SDK is TypeScript/Python only; no Go, Java, or other language bindings","Streaming support requires WebSocket upgrade; standard HTTP polling is slower","No built-in rate limiting or quota enforcement; requires external API gateway","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7479197744530031,"quality":0.49,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.549Z","last_scraped_at":"2026-05-03T13:58:21.998Z","last_commit":"2026-04-20T09:20:44Z"},"community":{"stars":20674,"forks":2997,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=coze-dev--coze-studio","compare_url":"https://unfragile.ai/compare?artifact=coze-dev--coze-studio"}},"signature":"PMqftqWQePqUXDxal4JD4cfYvc4muO6b2XGOjrmaI8DOr+67zyUO1qSDNhu3SMWiwjdvPt7GOfJMKE0iy2HRCw==","signedAt":"2026-06-21T16:58:55.596Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/coze-dev--coze-studio","artifact":"https://unfragile.ai/coze-dev--coze-studio","verify":"https://unfragile.ai/api/v1/verify?slug=coze-dev--coze-studio","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"}}