foss42/apidash
52.8
Adequate · 13 November 2026
55k
lines of production code
Dart
primary language
7
measurements over time
What this system is
Features
Add GenAI example app with provider and model selection
A new Flutter example application has been added to demonstrate the GenAI package. The app provides a user interface for selecting AI model providers and specific models, entering system and user prompts, and providing API credentials. It supports both single-response and streaming generation modes, allowing users to interact with various LLMs directly from the example.
_packages/genai/genai\example · high confidence
Add Insomnia collection parsing example
Added an example file demonstrating how to parse an Insomnia collection JSON string into the library's model objects, including handling requests, request groups, workspaces, environments, and cookie jars.
_packages/insomnia\collection/example · high confidence
Add Insomnia v4 collection import models
New data models have been added to parse Insomnia v4 collection exports, including \InsomniaCollection\, \Resource\, \Body\, \Formdatum\, \Parameter\, \Header\, \Cookie\, and \KVPairDatum\. The \Resource\ model now supports \environment\ and \kvPairData\ fields, and the \Body\ model includes \Formdatum\ support for form data and text. A helper class \InsomniaItem\ is provided to reconstruct the hierarchical structure of the collection from the flat list of resources.
_packages/insomnia\collection/lib/models · high confidence
Add JSON Explorer example application
The example application for the json\_explorer package has been added, providing a demo app that showcases the library's capabilities. It includes a main entry point with a list of sample JSON datasets (such as ISS location, country codes, and large files) to test the explorer's performance. The app implements the core UI features of the library, including a search interface with navigation between results, expand/collapse functionality for JSON nodes, and state management via Provider.
_packages/json\explorer/example · high confidence
Add Julia HTTP client code generation
Introduces a new code generator for the Julia language that produces HTTP request code using the \HTTP\ and \JSON\ packages. The generated code supports query parameters, custom headers, raw text/JSON bodies, and multipart form data (including file uploads), providing users with ready-to-run Julia snippets for API interactions.
lib/codegen/julia · high confidence
Add Postman Collection data models
Introduced the \PostmanCollection\ model and its associated sub-models (Info, Item, Request, Header, Url, Query, Body, Options, Raw, Formdatum) in the \packages/postman/lib/models\ directory. These freezed classes provide serialization and deserialization capabilities for Postman collection JSON data, including support for nested structures and null-safe handling via \includeIfNull: false\.
packages/postman/lib/models · high confidence
Add Rust code generation for multiple HTTP libraries
The Rust code generator now supports generating client code for five different HTTP libraries: \reqwest\, \actix\, \hyper\, \ureq\, and \curl\. Each generator handles standard request features including query parameters, JSON and raw text bodies, custom headers, and multipart form data uploads, allowing users to choose the Rust HTTP client that best fits their project's dependencies.
lib/codegen/rust · high confidence
Add Swift code generation for Alamofire and URLSession
New Swift code generators have been added for both the Alamofire and URLSession networking libraries. These generators produce Swift code that supports HTTP requests with query parameters, JSON and plain-text bodies, and multipart form data (including file uploads). Users can now generate Swift client code using either the popular Alamofire library or the standard URLSession API.
lib/codegen/swift · high confidence
Add cURL and HAR code generation capabilities
Users can now generate cURL command strings and HAR (HTTP Archive) JSON representations from HTTP request models. The new cURL generator constructs valid curl commands by mapping request methods, headers, bodies, and form data (including file uploads) into the appropriate command-line flags. The HAR generator converts request models into standard HAR JSON format, supporting boundary parameters for multipart requests.
lib/codegen/others · high confidence
Add terminal page UI with search, filtering, and timestamp toggle
A new TerminalPage has been added to display application logs. Users can search log entries by title or subtitle, filter logs by level (debug, info, warn, error) using a dedicated filter menu, and toggle the visibility of timestamps on log tiles. The page also includes buttons to clear logs and copy all entries to the clipboard.
lib/screens/terminal · high confidence
Add utility functions to filter Insomnia collection resources by type
A new utility file, insomnia\_utils.dart, has been added to provide helper functions for parsing Insomnia v4 collections. It introduces getRequestsFromInsomniaCollection and getEnvironmentsFromInsomniaCollection, which internally use getItemByTypeFromInsomniaCollection to filter and return resources (requests or environments) based on their type, handling null or empty resource lists gracefully.
_packages/insomnia\collection/lib/utils · high confidence
Added C\# code generation for HttpClient and RestSharp
New C\# code generation capabilities have been added, allowing users to generate HTTP client code in C\#. The implementation includes two distinct generators: one for the standard System.Net.Http.HttpClient and another for the RestSharp library. These generators handle various request components including query parameters, headers, raw bodies, JSON data, text data, and form data (both URL-encoded and multipart with file support).
lib/codegen/csharp · high confidence
Added Dart code generation for HTTP and Dio libraries
Users can now generate Dart client code for HTTP requests using either the standard \http\ package or the \dio\ library. This feature introduces new code generators (\DartHttpCodeGen\ and \DartDioCodeGen\) that produce async main functions handling URL parsing, query parameters, headers, request bodies (JSON, text, form-data), and multipart file uploads, complete with error handling and response printing.
lib/codegen/dart · high confidence
Added Go HTTP code generation
Users can now generate Go HTTP client code. This change introduces a new code generator (lib/codegen/go/http.dart) that produces Go source files using the standard net/http package, supporting URL parsing, query parameters, headers, raw request bodies (with backtick escaping), and multipart form data including file uploads.
lib/codegen/go · high confidence
Added HAR example demonstrating log parsing
An example file for the \har\ package has been added, showing how to parse HAR (HTTP Archive) JSON strings into structured objects using \harLogFromJsonStr\. The example includes sample data for various HTTP methods (GET, POST) and content types, illustrating how to access log metadata and entry details.
packages/har/example · high confidence
Added HAR log parsing and utility functions
The \packages/har/lib\ directory now includes generated freezed models and utilities for parsing HTTP Archive (HAR) logs. This adds the ability to deserialize HAR JSON data into strongly-typed Dart objects (such as \HarLog\, \Entry\, \Request\, and \Response\) and provides helper functions to extract request details from a parsed log.
packages/har/lib · high confidence
Added JavaScript code generation for Axios and Fetch APIs
New code generators have been added to the JavaScript library, enabling users to generate HTTP request code using the Axios library and the native Fetch API. These generators support both Node.js and browser environments, handling URL parameters, headers, and request bodies including multipart form data with file uploads.
lib/codegen/js · high confidence
Added Kotlin OkHttp code generation
The Kotlin code generator now supports generating client code using the OkHttp library. This new capability allows users to generate Kotlin snippets that utilize OkHttpClient for making HTTP requests, including support for query parameters, request bodies, headers, and multipart form data (including file uploads).
lib/codegen/kotlin · high confidence
Added Map extension for HTTP Content-Type header manipulation
The better\_networking package now exposes a MapExtension that simplifies working with HTTP Content-Type headers in Map structures. Users can check for the presence of a content-type key, retrieve its key and value, or remove the key entirely, streamlining header management in network operations.
_packages/better\networking/lib/extensions · high confidence
Added PHP code generation for cURL, Guzzle, and HttpPlug
Users can now generate PHP HTTP client code for three popular libraries: native cURL, Guzzle, and HttpPlug. The new generators in lib/codegen/php handle request initialization, query parameter encoding, header setting, and body rendering (including multipart/form-data with file uploads). This adds a new capability to export PHP client code directly from the tool.
lib/codegen/php · high confidence
Added Postman collection parsing utilities
The postman library now exposes utility functions to extract HTTP requests from a Postman collection. The new \postman\_utils.dart\ module provides \getRequestsFromPostmanCollection\ and \getRequestsFromPostmanItem\, which recursively traverse the collection structure to return a list of named requests, making it easier to consume Postman data within the application.
packages/postman/lib · high confidence
Added Python code generation for http.client and requests libraries
New code generation capabilities have been added for Python, supporting both the standard library's \http.client\ and the popular \requests\ library. Users can now generate Python code snippets for HTTP requests, including support for query parameters, JSON/text bodies, and multipart form data (with file uploads for the \requests\ generator). The \http.client\ generator handles HTTPS connections and manual boundary management for form data, while the \requests\ generator leverages \MultipartEncoder\ for easier form handling.
lib/codegen/python · high confidence
Added Ruby code generation for Faraday and Net::HTTP libraries
Users can now generate Ruby client code for HTTP requests using two popular libraries: Faraday and Net::HTTP. The new \RubyFaradayCodeGen\ class generates code leveraging Faraday's adapter system, including support for multipart file uploads and handling request bodies in DELETE requests. The \RubyNetHttpCodeGen\ class generates code using Ruby's standard library \net/http\, supporting URL parameters, headers, JSON/text bodies, and form data with file uploads.
lib/codegen/ruby · high confidence
Added cURL parser example application
An example application demonstrating the curl\_parser library has been added. It shows how to parse cURL command strings into structured objects and convert them back to strings, covering GET, HEAD, POST, and header handling scenarios.
_packages/curl\parser/example · high confidence
Added curl import and string utility utilities
The \apidash\_core\ package now includes utilities for importing HTTP requests from curl commands and generating random strings. The new \curl\_utils.dart\ file provides functions to parse single or multiple curl commands into \HttpRequestModel\ objects, handling URL, method, headers, query parameters, body, and form data (including clearing file paths for security). It also supports converting basic authentication credentials and mapping cookies, user agents, and referers. Additionally, \string\_utils.dart\ introduces a \RandomStringGenerator\ class for creating random alphanumeric strings, which is exported via the main \utils.dart\ barrel file.
_packages/apidash\core/lib/utils · high confidence
Added example project for better\_networking
A new example application has been added to the \better\_networking\ package, providing a Flutter UI that demonstrates how to use the library's core networking capabilities. The example includes buttons to perform GET and POST requests, cancel active HTTP requests, and handle streaming responses (specifically targeting a local LLM endpoint), along with standard project configuration files like \.gitignore\ and \analysis\_options.yaml\.
_packages/better\networking/example · high confidence
Added new Flutter code examples for dog breed and emoji displays
The documentation folder now includes two new Flutter example files: example4.dart, which demonstrates a grid-based UI displaying detailed information about different dog breeds, and example5.dart, which shows a table layout presenting dog emojis with their names, categories, and groups.
doc/gsoc/2025/codes · high confidence
Added onboarding and page base widgets
Introduced two new mobile widget components: OnboardingSlide, which renders a Lottie animation with a title and description for onboarding screens, and PageBase, a scaffold wrapper that handles the app bar, body padding, and platform-specific window insets.
lib/screens/mobile/widgets · high confidence
Added request consolidation logic for API tool generation
A new \APIDashRequestDescription\ class has been introduced in \lib/apitoolgen/request\_consolidator.dart\ to structure and format HTTP request details. This component aggregates endpoint, method, query parameters, headers, and body content (text, JSON, or form-data) into a standardized description, providing a \generateREQDATA\ getter that outputs a human-readable summary of the REST API request structure for use in the tool generation process.
lib/apitoolgen · high confidence
Added string utility extensions for capitalization, clipping, and null-checking
The \apidash\_core\ package now exposes reusable string manipulation helpers via new extension methods. Users can capitalize strings with \capitalize()\, truncate them with ellipses using \clip(int limit)\, and safely check for null or empty values on nullable strings using \isNullOrEmpty()\. These utilities are exported through the \extensions.dart\ barrel file for convenient access across the application.
_packages/apidash\core/lib/extensions · high confidence
Added support for Digest, OAuth 1.0, and enhanced OAuth 2.0 authentication flows
The authentication utility layer now supports Digest authentication, including automatic challenge-response handling and support for MD5 and SHA-256 algorithms. OAuth 1.0a is fully implemented with HMAC-SHA1 and Plaintext signature methods. OAuth 2.0 capabilities have been expanded to include the Authorization Code grant (with local callback server support for desktop platforms and webview support for mobile) and the Client Credentials grant, both featuring optional credential file persistence. JWT generation has also been enhanced to support private key-based algorithms (RS, PS, ES, EdDSA) in addition to existing symmetric options.
_packages/better\networking/lib/utils/auth · high confidence
DashBot task buttons and interactive response actions
This change introduces a new set of interactive widgets for the DashBot chat interface. It adds a task-button panel that provides context-specific quick actions for HTTP, WebSocket, and MQTT API types (e.g., explaining connections, debugging errors, generating code or tests). It also adds a chat bubble component that renders system messages with Markdown and displays actionable buttons below them, such as copying the response, importing OpenAPI specs via a new operation picker dialog, generating code blocks with copy support, applying auto-fixes, and uploading attachments. These widgets enable users to perform common tasks directly from the chat conversation.
lib/dashbot/widgets · high confidence
Dashbot AI assistant now supports WebSocket and MQTT debugging and code generation
The Dashbot AI assistant has been expanded to handle WebSocket and MQTT protocols in addition to standard HTTP APIs. This update introduces specialized system prompts and action schemas for debugging connection issues (such as TLS mismatches, client ID collisions, or missing authorization headers) and analyzing message logs for both WebSocket and MQTT connections. It also adds capabilities to generate integration code, documentation, and test cases specifically for WebSocket and MQTT tasks, alongside new plain-language explanations for MQTT concepts like Last Will, topic wildcards, and MQTT v5 features.
lib/dashbot/prompts · high confidence
Dashbot chat interface and task-based routing
This change introduces the Dashbot chat UI and task-specific routing logic. Users can now interact with a chat interface that supports streaming responses and auto-scrolling, and access context-aware task buttons for WebSocket and MQTT connections (e.g., explaining connections, debugging messages, generating tests). The routing system automatically determines whether to show the default, home, or chat view based on request activity, and provides a utility to safely parse JSON messages that may be wrapped in markdown code fences.
lib/dashbot/utils · high confidence
Environment editor now separates variables and secrets into distinct tabs
The environment editor pane now uses a tabbed interface to manage environment configuration, splitting entries into 'Variables' and 'Secrets' tabs. This change introduces new \EditEnvironmentVariables\ and \EditEnvironmentSecrets\ widgets that handle their respective data types independently, while a \VariablesTabs\ component manages the navigation and indicator visibility based on the presence of entries in each category.
_lib/screens/envvar/editor\pane · high confidence
Import support for HAR, cURL, Postman, and Insomnia collections
Users can now import API requests and environments from HAR logs, cURL commands, Postman collections, and Insomnia collections. The new import logic in the core library parses these formats into the application's internal request model, supporting headers, query parameters, raw bodies, and form data (including file uploads). Additionally, Insomnia environment variables are imported as application environments.
_packages/apidash\_core/lib/import\export · high confidence
Initial code generation engine for HTTP client libraries
The application now includes a code generation system that produces HTTP client code snippets for a wide range of languages and libraries. This feature allows users to export their API requests as ready-to-use code for C\# (HttpClient, RestSharp), Dart (Dio, http), Go, Java (AsyncHttpClient, HttpClient, OkHttp, Unirest), JavaScript/Node.js (Axios, Fetch), Julia, Kotlin (OkHttp), PHP (cURL, Guzzle, HttpPlug), Python (HttpClient, Requests), Ruby (Faraday, Net::HTTP), Rust (Actix, cURL, Hyper, Reqwest, ureq), Swift (Alamofire, URLSession), and C (cURL), as well as generic formats like cURL and HAR. The system handles URL scheme defaults and multipart boundary generation for supported targets.
lib/codegen · high confidence
Initial project scaffolding and documentation
Establishes the foundational structure for the API Dash project by adding essential configuration and documentation files. This includes a \.gitignore\ to exclude build artifacts and IDE files, \analysis\_options.yaml\ for Dart linting, and build configuration files for Flutter launchers and native splash screens. The repository is now equipped with standard open-source governance documents such as \LICENSE\, \CONTRIBUTING.md\, \CODE\_OF\_CONDUCT.md\, \SECURITY.md\, and \ROADMAP.md\, alongside detailed \README.md\ and \INSTALLATION.md\ guides to support user onboarding and developer contributions.
(repo-wide) · high confidence
Initial release of the Agentic Engine infrastructure
This change introduces the foundational components for the new agentic engine within the GenAI package. It adds the \AIAgentService\ class, which provides a \callAgent\ entry point that orchestrates AI requests through a governor mechanism featuring exponential backoff retry logic and validation. The service supports system prompt templating via variable substitution. These capabilities are exposed through the \agentic\_engine\ library, which also includes the \AIAgent\ abstract interface and \AgentInputs\ model to define agent behavior and input structures.
_packages/genai/lib/agentic\engine · high confidence
Initial release of the better\_networking package
The \better\_networking\ package is introduced as a standalone Dart library for simplifying HTTP requests and streaming operations. It provides unified request modeling via \HttpRequestModel\, consistent response handling with \HttpResponseModel\, and support for both REST and GraphQL APIs, including Server-Sent Events (SSE) streaming. The package includes client management with cancellation and lifecycle control, along with built-in utilities for parsing headers and content types. This entry reflects the initial packaging, including configuration files like \pubspec.yaml\, \analysis\_options.yaml\, and \build.yaml\, as well as documentation and licensing (Apache 2.0).
(repo-wide) · high confidence
Initial release of the genai unified Dart/Flutter package
This change introduces the \genai\ package, a unified Dart/Flutter library for interacting with multiple Generative AI providers (Google Gemini, OpenAI, Anthropic, Azure OpenAI, and Ollama) using a single request model. The package provides a unified \AIRequestModel\ and utilities for both normal and streaming responses, allowing users to configure parameters like temperature and max tokens across providers. It includes a \models.json\ file defining supported models for each provider and is licensed under Apache 2.0.
packages/genai · high confidence
Initial release of the json\_explorer Flutter package
This change introduces the \json\_explorer\ package, a Flutter widget for rendering, viewing, and interacting with JSON data. It provides a tree-view interface with expand/collapse capabilities for classes and arrays, dynamic search with highlighting, and configurable theming via \JsonExplorerTheme\. The package includes a \JsonExplorerStore\ for state management (compatible with Provider), supports custom formatters for keys and values, and allows dynamic styling of property values based on their content. The initial release is version 0.1.2, which adds support for \maxRootNodeWidth\ to address issue \#106.
_packages/json\explorer · high confidence
Initial release of the seed package with data models
The seed package is introduced, providing foundational data models for the application. It includes a \FormDataModel\ to represent form entries with a name, value, and type (text or file), and a \NameValueModel\ for generic name-value pairs. These models are implemented using Freezed for immutable state and JSON serialization, and are exported via the main \seed.dart\ library entry point.
packages/seed/lib · high confidence
Introduce AD-prefixed Material 3 widget components
The design system now exports a new set of standardized UI components (prefixed with AD) to replace default Flutter widgets, ensuring consistent Material 3 styling across the application. This update adds ADFilledButton, ADIconButton, ADTextButton, ADCheckBox, ADDropdownButton, ADPopupMenu, ADListTile, ADOutlinedTextField, and ADRawTextField, along with helper utilities like getTextFieldInputDecoration and getSnackBar. These components centralize visual tokens and behaviors, meaning users of the design system will now interact with these specific styled variants rather than the raw Material library widgets.
_packages/apidash\_design\system/lib/widgets · high confidence
Introduce AI-powered UI generation with SDUI preview and export
Users can now generate UI components from API responses using an AI-driven workflow. The new \GenerateUIDialog\ orchestrates a multi-step process: first, a \FrameWorkSelectorPage\ allows users to input content and target a framework (currently hardcoded to Flutter); next, the system generates an SDUI representation via \apidash\_agent\_calls\; finally, an \SDUIPreviewPage\ renders the result using the \stac\ library and provides controls to export the generated code to the clipboard or request further modifications via natural language prompts.
_lib/screens/common\_widgets/agentic\_ui\_features/ai\_ui\designer · high confidence
Introduce DashBot chat interface and routing
Added a new DashBot feature that provides a chat interface for GenAI interactions. This includes new data models for chat messages, actions, attachments, and state management, along with a remote repository to execute AI requests. The feature is accessible via new application routes (home, default, and chat screens) and includes logic to automatically manage environment variables for base URLs when importing OpenAPI specifications.
(repo-wide) · high confidence
Introduce DashBot state management and service providers
Added new Riverpod providers in lib/dashbot/providers to manage DashBot-specific state and services. This includes an AttachmentsProvider for handling chat attachments, a ChatViewmodel for orchestrating chat interactions (including code generation, cURL/OpenAPI import flows, and WebSocket/MQTT support), a DashbotActiveRouteProvider for managing navigation state, and a DashbotWindowNotifier for UI window controls. Additionally, service providers for prompt building, URL environment handling, request application, and auto-fixing are wired up to integrate with the core application state.
lib/dashbot/providers · high confidence
Introduce EnvironmentModel for managing environment variables
The \apidash\_core\ package now includes an \EnvironmentModel\ to represent API environments, allowing users to define environments with a name and a list of variables. Each variable is modeled by \EnvironmentVariableModel\, supporting a key-value pair, an enabled/disabled state, and a type that can be either a standard variable or a secret. This model provides serialization support and utility classes for variable suggestions, forming the data structure for environment configuration within the core library.
_packages/apidash\core/lib/models · high confidence
Introduce History screen for viewing past requests
Added a new History screen (lib/screens/history) that allows users to view, select, and inspect previously made API requests. The implementation includes a sidebar (HistoryPane) listing requests grouped by date, a viewer (HistoryViewer) for desktop layouts showing a list and details side-by-side, and a details pane (HistoryDetails) displaying request/response data and generated code. A dedicated empty state (HistoryEmpty) is shown when no history exists, and a mobile-friendly sheet (HistorRequestsScrollableSheet) is provided for selecting requests on smaller screens.
lib/screens/history · high confidence
Introduce apidash\_core library with shared constants and exports
The new apidash\_core package provides a centralized library for shared code, exporting core models, utilities, extensions, and import/export functionality. It also exposes key third-party dependencies (freezed\_annotation, genai, curl\_parser, openapi\_spec) for use by other packages. Additionally, a new EnvironmentVariableType enum is defined to distinguish between standard variables and secrets.
_packages/apidash\core/lib · high confidence
Introduce apidash\_design\_system package
The new apidash\_design\_system package is now available, providing a centralized library for design tokens, widget extensions, and reusable widgets. It exports the Google Fonts package, custom extensions, and a set of widgets to support consistent UI development across the application.
_packages/apidash\_design\system/lib · high confidence
Introduce better\_networking package with core API types and constants
The new \better\_networking\ library exports a centralized set of constants and type definitions for the application's networking layer. It defines \APIType\ to support REST, AI, GraphQL, WebSocket, MQTT, and gRPC protocols, and \APIAuthType\ to cover authentication methods including Basic, API Key, Bearer, JWT, Digest, OAuth 1.0, and OAuth 2.0. The package also establishes default configurations for HTTP verbs, URI schemes (defaulting to HTTPS), WebSocket schemes (defaulting to WSS), and content types, while exposing streaming response type lists and utility constants for JSON encoding and header management.
_packages/better\networking/lib · high confidence
Introduce centralized design tokens for colors, typography, and measurements
The design system now uses a dedicated \tokens\ directory to centralize visual configuration. This introduces structured color definitions for HTTP methods, status codes, and WebSocket events, alongside Material 3 light and dark themes seeded from a blue primary. Typography is standardized using Open Sans with Source Code Pro for code blocks, and emoji support is explicitly handled via Noto Color Emoji on native platforms. A comprehensive set of spacing, padding, and border-radius constants is also provided to ensure consistent layout measurements across the application.
_packages/apidash\_design\system/lib/tokens · high confidence
Introduce curl\_parser library for parsing cURL commands
Added a new \curl\_parser\ package that provides a \Curl\ model (generated with Freezed and JSON serialization) to parse cURL command strings into structured Dart objects and serialize them back. The parser handles HTTP methods, URIs, headers, request bodies, cookies, authentication, SSL flags, and redirects, and now supports multipart form-data parsing via the \--form\ flag. It also includes utilities to normalize shell continuations and safely ignore unrecognized flags during parsing.
_packages/curl\parser/lib · high confidence
Introduce json\_field\_editor package for JSON-aware text editing
The new \json\_field\_editor\ package provides a \JsonField\ widget that extends Flutter's \TextField\ to support syntax highlighting for JSON elements (keys, strings, numbers, booleans, nulls, and special characters) and real-time validation with customizable error display. It includes a \JsonTextFieldController\ for programmatic formatting and sorting of JSON content, and adds \doInitFormatting\ and \fieldKey\ parameters to control initial formatting behavior and widget identification.
_packages/json\_field\editor · high confidence
Introduce multi\_trigger\_autocomplete\_plus package with no-trigger and customizable trigger support
This change adds the \multi\_trigger\_autocomplete\_plus\ Flutter package, a fork of \multi\_trigger\_autocomplete\ that introduces \AutocompleteNoTrigger\ to display suggestions without requiring a trigger character, makes the \triggerEnd\ character customizable instead of using a hardcoded space, and improves handling of triggers that share a common prefix (such as \{\ and \{{\). The package also includes an example app demonstrating mention, hashtag, and emoji autocomplete features.
_packages/multi\_trigger\_autocomplete\plus · high confidence
Introduce terminal logging with level-based filtering
This change adds a new terminal logging subsystem to the application, introducing data models for network, JavaScript, and system log entries along with the corresponding UI widgets to display them. Users can now view structured logs from different sources (network requests, JS console, and system events) and filter these entries by severity level (debug, info, warn, error) using a new dialog-based filter menu.
lib/terminal · high confidence
Introduces centralized connection management and gRPC reflection capabilities
The \lib/services\ directory now includes a new \ConnectionManager\ singleton that unifies the lifecycle of WebSocket, MQTT (v3.1.1 and v5), and gRPC connections, allowing users to manage active connections per request tab and update heartbeat intervals on live WebSocket connections. Additionally, a new \GrpcReflectionService\ has been added to enable gRPC server reflection, allowing the application to discover and inspect service schemas and method definitions dynamically from the server.
lib/services · high confidence
Introduces dedicated UI components for all supported authentication types
The \lib/screens/common\_widgets/auth\ directory now contains specific field widgets for Basic, Bearer, API Key, Digest, JWT, OAuth 1, and OAuth 2 authentication, orchestrated by a new \AuthPage\ that dynamically renders the correct form based on the selected type. These components provide a unified interface for entering credentials, with specific enhancements such as PKCE and token expiration handling for OAuth 2, private key and algorithm selection for JWT, and digest-specific fields (realm, nonce, algorithm) for Digest auth. All fields support a \readOnly\ mode for history views and utilize the \ADPopupMenu\ for consistent selection controls.
_lib/screens/common\widgets/auth · high confidence
Introduces modular interface for AI model providers
The genai package now exposes a new modular interface in \packages/genai/lib/interface\ that standardizes how AI models are configured and invoked. This change introduces a \ModelAPIProvider\ enum and a provider map supporting OpenAI, Anthropic, Gemini, Azure OpenAI, and Ollama. Each provider is implemented as a dedicated class (e.g., \OpenAIModel\, \AnthropicModel\) that handles specific API requirements, such as authentication headers (Bearer vs. API Key), request body structures, and output parsing for both streaming and non-streaming responses. Default configurations for temperature, top-p, max tokens, and streaming are also defined within this interface layer.
packages/genai/lib/interface · high confidence
New AI configuration UI widgets and build tooling
This change introduces a new set of Flutter widgets for configuring AI model parameters, including AIConfigBool for boolean toggles, AIConfigField for text and numeric inputs, and AIConfigSlider for range-based values. These components allow users to interactively adjust model settings within the application. Additionally, a new build tool (json\_to\_dart.dart) and pre-publish script have been added to automatically generate Dart model data from JSON files, streamlining the development and release process.
packages/genai/lib/widgets, packages/genai/tool · high confidence
New AI model selection UI components
Added a new set of widgets in lib/screens/common\_widgets/ai to manage AI model configuration: AIModelSelector (ConsumerWidget), AIModelSelectorButton, AIModelSelectorDialog, and dialog\_add\_ai\_model. The selector watches the current request's AI model and exposes a button that opens a dialog for choosing a provider and model, entering API keys/endpoints, and adding custom models. This provides a dedicated UI for configuring AI request models within the app.
_lib/screens/common\widgets/ai · high confidence
New AI request and model availability data models
The \packages/genai/lib/models\ directory now includes \AIRequestModel\ and \AvailableModels\ as the core data structures for AI interactions. \AIRequestModel\ standardizes request configuration, supporting multiple providers (OpenAI, Anthropic, Gemini, Azure OpenAI, Ollama) and introducing a \stream\ boolean field to enable streaming responses. \AvailableModels\ provides a structured, versioned list of supported models and providers, sourced from \models\_data.g.dart\ which lists specific models like GPT-5, Claude 4.5/4.6, and Gemini 3. \ModelConfig\ and \ModelConfigValue\ classes handle dynamic model parameters (boolean, slider, numeric, text) with serialization support.
packages/genai/lib/models · high confidence
New AI request execution and model management utilities
The genai package now includes dedicated utility files for handling generative AI interactions and model discovery. \ai\_request\_utils.dart\ introduces functions to execute standard and streaming HTTP requests to AI models, including logic to parse Server-Sent Events (SSE) and format word-by-word output for streaming responses. \model\_manager.dart\ provides static methods to fetch available models from remote sources and specifically queries the local Ollama instance (using the \/api/ps\ endpoint) to identify installed and running models. These utilities are exported via \utils.dart\ to support the package's modular interface.
packages/genai/lib/utils · high confidence
New Agentic Service Agents for API and UI Generation
This location introduces a new set of AI agent implementations within the agentic services layer, specifically designed to handle distinct stages of API tool and UI generation. The diff adds new files for \ApiToolBodyGen\, \APIToolFunctionGenerator\, \IntermediateRepresentationGen\, \ResponseSemanticAnalyser\, \StacToFlutterBot\, \StacGenBot\, and \StacModifierBot\. These agents replace or supplement previous logic by providing specialized system prompts and output formatters that strip code block markers (e.g., \\\python, \\\json) and apply specific transformations, such as converting 'bold' to 'w700' for STAC outputs. The \agents.dart\ barrel file now exports these new components, making them available for use in the broader agentic workflow.
_lib/services/agentic\services/agents · high confidence
New C code generator for curl-based HTTP requests
A new C code generator (CCurlCodeGen) has been added to the C codegen module, enabling users to generate C source code that uses libcurl to perform HTTP requests. The generated code handles URL configuration, custom methods, raw body data, multipart form data (including file uploads), custom headers, and response handling with status code and body output.
lib/codegen/c · high confidence
New Dashboard layout and comprehensive Settings page
The application now features a redesigned Dashboard screen that replaces the previous navigation structure with a vertical Rail containing Requests, Variables, History, and Logs (renamed from Terminal), along with About and Settings buttons. This layout integrates the DashBot AI assistant, which appears as a floating action button when enabled. A new Settings page has been introduced, allowing users to configure the theme, toggle DashBot, manage collection pane scrollbar visibility, set default URI and WebSocket schemes, disable SSL (desktop only), choose a default code generator language, select an AI model, control response saving, enable a save-on-close prompt, and adjust history retention and WebSocket message limits.
lib/screens · high confidence
New HTTP client management, streaming service, and local OAuth callback server
The \better\_networking\ package now includes a dedicated \HttpClientManager\ to handle client lifecycle, cancellation tracking, and optional JSON Accept header injection. The HTTP service layer has been refactored to support streaming requests via \streamHttpRequest\ and includes specific handling for GraphQL APIs. Additionally, a new \OAuthCallbackServer\ provides a local HTTP server on desktop platforms to handle OAuth2 callback flows, including timeout and cancellation support.
_packages/better\networking/lib/services · high confidence
New HTTP request and response data models
The \better\_networking\ package now exposes \HttpRequestModel\ and \HttpResponseModel\ to represent network operations. \HttpRequestModel\ centralizes request configuration, including method, URL, headers, parameters, body content, and authentication details, while providing helpers to determine body presence and content type. \HttpResponseModel\ captures response data such as status code, headers, body content (as string or bytes), and timing, and includes support for Server-Sent Events (SSE) via an \sseOutput\ field. These models are generated using Freezed and JSON serialization, ensuring consistent data handling and immutability for HTTP interactions.
_packages/better\networking/lib/models · high confidence
New Java code generation support for AsyncHttpClient, HttpClient, OkHttp, and Unirest
Users can now generate Java HTTP client code from four different libraries: the built-in java.net.http.HttpClient, the popular OkHttp library, the asynchronous AsyncHttpClient, and the convenience library Unirest. The new code generators in lib/codegen/java support generating requests with query parameters, custom headers, raw/JSON bodies, and multipart form data (including text fields and file uploads). Each generator produces a complete, runnable Java class with the appropriate imports and request execution logic for its respective library.
lib/codegen/java · high confidence
New agentic service layer for AI-driven code generation
The \lib/services/agentic\_services\ directory now contains a new \agent\_caller.dart\ and \apidash\_agent\_calls.dart\ that implement the core logic for invoking AI agents. This change introduces a dedicated caller class (\APIDashAgentCaller\) to handle agent interactions, replacing previous implementations. The new service exposes functions to generate SDUI code from API responses, modify SDUI code via prompts, and generate API tool code based on request data, utilizing specific agents like \ResponseSemanticAnalyser\, \IntermediateRepresentationGen\, and \StacGenBot\.
_lib/services/agentic\services · high confidence
New cURL and OpenAPI import services for Dashbot
This change introduces two new services in the \lib/dashbot/services\ directory to support importing API definitions. \CurlImportService\ parses pasted cURL commands into standard HTTP request models, handling unsupported flags (like insecure mode or redirects) by ignoring them and noting their absence. \OpenApiImportService\ parses OpenAPI specifications (JSON/YAML) to extract metadata (endpoints, methods, tags) and generate request payloads. It includes a specific workaround to handle parsing failures caused by empty security arrays in some OpenAPI specs. These services are exported via \services.dart\ to make them available to the rest of the application.
lib/dashbot/services · high confidence
New common UI widgets and refactored environment fields
This change introduces a suite of new reusable UI components in the common\_widgets directory, including API type and environment selectors, a code pane with DashBot fallback for missing native codegen, and a new navigation bar button. It also refactors environment input fields (URL, headers, auth, cells) to use a new EnvironmentTriggerField with multi-trigger autocomplete, improving how environment variables are inserted and displayed.
_lib/screens/common\widgets · high confidence
New data models for gRPC, MQTT, and request history
The \lib/models\ directory now includes new model definitions to support additional protocols and request history. \GrpcRequestModel\ introduces data structures for gRPC requests, including streaming types, TLS settings, and metadata. \MQTTRequestModel\ adds support for MQTT v5, featuring broker configuration, QoS, TLS, and v5-specific properties like session expiry and user properties. Additionally, \HistoryMetaModel\ and \HistoryRequestModel\ provide the data structures for persisting and managing request history, linking metadata with specific request types (HTTP, AI, WebSocket, MQTT, gRPC) and optional pre/post-request scripts.
lib/models · high confidence
New design system extensions for color blending and window sizing
The design system now exposes utility extensions to simplify common UI logic. Developers can use the new \ColorExtension\ to easily blend colors for dark mode styling via the \toDark\ getter, and the \MediaQueryExtension\ on \BuildContext\ provides convenient boolean getters (\isCompactWindow\, \isMediumWindow\, etc.) and dimension accessors (\width\, \height\) to adapt layouts to different screen sizes.
_packages/apidash\_design\system/lib/extensions · high confidence
New empty-state guidance and structured request editor layout
When no API request is selected, the editor pane now displays a 'Get Started' screen with a call-to-action to create a new request and quick tips for organizing collections or importing from Postman/Insomnia. When a request is selected, the editor uses a new top bar showing the API type, request name, and actions (rename, duplicate, delete), alongside an environment dropdown, replacing the previous layout.
_lib/screens/home\_page/editor\pane · high confidence
New environment management interface with sidebar and editor
Users can now manage environment variables through a dedicated Environment page featuring a sidebar list for selecting, filtering, and reordering environments, alongside a main editor pane for viewing and editing variable key-value pairs. The interface supports renaming, duplicating, and deleting custom environments (while protecting the global environment), and integrates with the application's design system for consistent styling across different window sizes.
lib/screens/envvar · high confidence
New mobile dashboard, navigation, and onboarding flow
The mobile interface now features a dedicated dashboard layout with a bottom navigation bar for switching between Requests, Variables, History, Logs, and Settings. A new onboarding screen has been added to guide users through the app's core features using a carousel slider. The dashboard also includes responsive logic to adjust the navigation bar's position based on window size and drawer state.
lib/screens/mobile · high confidence
New mobile request-response page with Dashbot integration
The mobile requests interface has been restructured into a dedicated RequestResponsePage featuring a bottom navigation bar and a segmented tab view. Users can now toggle the Dashbot assistant on and off via a button in the bottom bar; when enabled, the main content area switches to the DashbotTab, otherwise it displays the standard Request, Response, and Code tabs. The bottom bar also includes the Send Request button, which automatically switches to the Response tab upon activation.
_lib/screens/mobile/requests\page · high confidence
New system prompt templates and rulesets for SDUI and API tool generation
The \lib/templates\ area now includes a comprehensive set of new prompt templates and rulesets that define how the system generates Server Driven UI (SDUI) code and API tool definitions. This includes a \stac\_ruleset.dart\ file establishing the widget catalog and syntax rules for the SDUI language, alongside system prompts for semantic analysis, intermediate representation generation, and converting SDUI to Flutter code. Additionally, new templates for API tool generation (\apitool\_bodygen\_prompt.dart\, \apitool\_funcgen\_prompt.dart\) and a \tool\_templates.dart\ file with a selector for Python and JavaScript tool formats (supporting LangChain, Microsoft Autogen, and general formats) have been added to support dynamic API tool creation.
lib/templates · high confidence
New tool generation dialog with responsive layout and framework selection
A new GenerateToolDialog has been introduced in the tool generation feature, allowing users to select an AI agent framework (Gemini, OpenAI, LangChain, Microsoft AutoGen, Mistral, Anthropic) and a target language (Python, JavaScript/NodeJS) to generate API tool code. The dialog features a responsive layout that displays the requirements selector and generated code side-by-side on larger screens, while using a stacked view on smaller windows. It includes a code previewer with syntax highlighting and a copy button for the generated tool code, and handles errors such as missing default AI models or generation failures with user-friendly snackbars.
_lib/screens/common\_widgets/agentic\_ui\_features/tool\generation · high confidence
New unified authentication data models for API requests
The \better\_networking\ package now includes a comprehensive set of data models to represent various authentication methods, enabling users to configure API requests with greater flexibility. The new \AuthModel\ acts as a central union type supporting Basic, API Key, Bearer, JWT, Digest, OAuth 1, and OAuth 2 authentication. Specific models have been added for each method: \AuthBasicAuthModel\ for username/password credentials, \AuthApiKeyModel\ for key-based auth with configurable header/query locations, \AuthBearerModel\ for token-based access, \AuthJwtModel\ for JSON Web Tokens with support for private keys and various algorithms, \AuthDigestModel\ for HTTP Digest authentication, and \AuthOAuth1Model\ and \AuthOAuth2Model\ for OAuth flows. These models are generated using Freezed and JsonSerializable, providing immutable data structures with copy-with functionality and JSON serialization, allowing developers to easily define and pass authentication details in their networking calls.
_packages/better\networking/lib/models/auth · high confidence
New utility library for code generation, environment variables, and protocol support
The application now includes a comprehensive set of utility modules in lib/utils to support new capabilities. Code generation for non-HTTP protocols (WebSocket, MQTT, gRPC) is now handled by DashBot, while HTTP requests retain native code generation. Environment variable substitution is now supported across request URLs, headers, parameters, form data, and all authentication models (Basic, Bearer, API Key, JWT, Digest, OAuth1, OAuth2). Protocol-specific utilities have been added, including gRPC proto file parsing and binary response decoding, HAR export functionality, and JavaScript runtime support for pre/post-request scripts. Additional utilities cover file management, history grouping and retention, header suggestions, and UI color theming.
lib/utils · high confidence
New utility library for request handling, content parsing, and URI management
The \better\_networking\ package now includes a comprehensive set of utility functions in \lib/utils\ to support request construction and response processing. This includes \http\_request\_utils.dart\ for converting key-value rows to maps (supporting multi-value headers) and handling form data, \content\_type\_utils.dart\ for parsing Content-Type headers into structured types, and \uri\_utils.dart\ which introduces smart URI validation and automatic scheme detection for HTTP (defaulting to HTTP for localhost) and WebSocket connections (defaulting to ws/wss based on host). Additionally, \http\_response\_utils.dart\ provides body formatting for JSON, XML, and HTML, while \platform\_utils.dart\ exposes platform detection logic used by OAuth flows.
_packages/better\networking/lib/utils · high confidence
Prompt builder now supports WebSocket and MQTT context generation
The PromptBuilder service has been updated to generate specific context blocks for WebSocket and MQTT API requests, in addition to standard HTTP. When building system prompts, the service now detects the request type and includes relevant connection details, such as WebSocket heartbeat and auto-reconnect status, or MQTT broker settings, topics, and QoS levels. This allows the AI agent to provide more accurate assistance for these specific protocol types by having access to their unique configuration and message history.
lib/dashbot/services/agent · high confidence
Read-only history view for AI, WebSocket, MQTT, and gRPC requests
The History screen now supports inspecting past requests for AI, WebSocket, MQTT, and gRPC protocols in a read-only mode. The History Request Pane displays protocol-specific details: AI requests show system/user prompts, API keys, and model configuration; WebSockets show connection settings like auto-reconnect and heartbeat intervals; MQTT shows broker connection data, subscribed topics, and user properties; and gRPC shows target, service, method, and metadata. The History Response Pane renders WebSocket, MQTT, and gRPC messages using a Realtime Event Stream view, while standard HTTP/GraphQL responses use the existing response tabs. The History URL Card displays the selected AI model for AI requests, and the History Scripts Tab allows viewing pre- and post-request scripts. Action buttons allow duplicating history entries or navigating to the original request if it still exists in the collection.
_lib/screens/history/history\widgets · high confidence
Unified import dialog with drag-and-drop support for multiple formats
Users can now import API requests from Postman, Insomnia, HAR, and cURL files directly via a new import dialog that supports file dropping. The dialog reads the dropped file, determines the format, and adds the parsed requests to the current collection, providing success or error feedback via snackbars.
lib/importer · high confidence
Architecture
Centralized state management via new provider architecture
The application's state management has been reorganized into a dedicated \lib/providers\ directory, introducing a structured set of Riverpod providers to manage distinct application domains. This change introduces \collection\_providers.dart\ for managing API request collections and selection, \environment\_providers.dart\ for handling environment variables and their substitution, \history\_providers.dart\ for persisting and retrieving request history, and \terminal\_providers.dart\ for controlling the in-app logging console. Additionally, \js\_runtime\_notifier.dart\ centralizes the lifecycle and execution state of the JavaScript runtime used for pre- and post-request scripts, while \settings\_providers.dart\ and \ui\_providers.dart\ manage application configuration and UI state respectively. This consolidation replaces scattered state logic with a unified, modular provider system.
lib/providers · high confidence
Behavioural changes
AI request editor now supports prompt, authorization, and configuration tabs
The AI request editing interface has been restructured into a tabbed layout with three distinct sections: Prompt, Authorization, and Configurations. Users can now edit system and user prompts directly, manage API keys for authorization, and adjust model-specific settings (such as boolean flags, numeric values, text fields, and sliders) via a dedicated configuration tab. This change replaces the previous single-pane view with a more organized, multi-tab experience for fine-tuning AI requests.
_lib/screens/home\_page/editor\_pane/details\_card/request\_pane/ai\request · high confidence
Dashbot UI restructured with window/tab modes and expanded protocol support
The Dashbot interface now supports both a floating window mode (DashbotWindow) and an embedded tab mode (DashbotTab), with logic to hide the floating window when other windows are open and to toggle visibility based on user interaction. The chat capabilities have been expanded to include WebSocket and MQTT protocols, introducing new message types (e.g., explainWsConnection, debugMqttConnection) and action targets (wsRequestModel, mqttRequestModel). The auto-fix service now applies changes to WebSocket and MQTT request models, including specific handling for MQTT fields like brokerUrl and useTLS, while also supporting cURL and OpenAPI imports for HTTP requests.
lib/dashbot · high confidence
Introduces workspace-based persistence and platform-aware app initialization
The application now requires users to select a workspace folder on first launch (desktop) or after onboarding (mobile), storing all data in Hive within that directory rather than a fixed global location. The startup flow has been restructured to initialize the Stac library, fetch available LLM models, and conditionally configure window management (size/position) only on desktop platforms. Additionally, the app now supports a 'Save on close' feature that prompts users to save unsaved changes before the window closes, and it automatically clears request history based on configurable retention periods.
lib · high confidence
New Collection Pane with filtering, reordering, and scrollbar settings
The home page now uses a dedicated CollectionPane widget that displays requests in a sidebar. Users can reorder requests via drag-and-drop (with mobile-specific drag handling), filter the list by name or URL using a search field, and toggle a persistent scrollbar via a new settings option. The pane also integrates an import dialog and an environment dropdown on medium-sized windows, replacing the previous layout structure.
_lib/screens/home\page · high confidence
New MQTT request pane with per-topic QoS and v5 user properties
The MQTT request editor has been replaced with a new tabbed interface (Message, Topics, Properties, Auth, Settings) that uses the Apidash design system. Users can now manage multiple topic subscriptions in a table, each with its own per-topic QoS dropdown (0–2) and enable/disable toggle, allowing live subscription changes. For MQTT 5.0 requests, a new Properties tab appears, enabling key/value User Properties to be edited. Plain-language help icons are added to controls to explain settings without jargon.
_lib/screens/home\_page/editor\_pane/details\_card/request\pane/mqtt · high confidence
Redesigned UI components using the new design system
The widget library has been migrated to use the new \apidash\_design\_system\ components, replacing previous Flutter Material widgets with custom styled elements like \ADIconButton\, \ADFilledButton\, and \ADDropdownButton\. This change introduces a consistent visual language across the application, including updated button styles, card layouts for request history and environments, and new dialogs for import and history retention.
lib/widgets · high confidence
Refactored URL card UI into modular components with protocol-aware state handling
The URL input card in the editor pane has been restructured into distinct, reusable widgets (URLTextField, SendRequestButton, DropdownButtonHTTPMethod, etc.) to improve maintainability. This change introduces protocol-specific behavior for the URL input field: it now correctly handles initial values and hint text for REST, GraphQL, AI, WebSocket, MQTT, and gRPC APIs. For MQTT specifically, the URL field now parses and extracts port, TLS, and WebSocket settings from the broker URL string. The send button label dynamically adapts to the API type (e.g., 'Connect/Disconnect' for WebSocket/MQTT, 'Reflect' for gRPC when no method is selected). The layout also adjusts spacing and component visibility based on window size and API type.
_lib/screens/home\_page/editor\_pane/url\card · high confidence
Request pane components restructured into dedicated files
The request pane UI logic has been reorganized into separate, dedicated files for each protocol and sub-section. This includes new files for authentication (request\_auth.dart, request\_auth\_grpc.dart), request body handling (request\_body.dart, request\_form\_data.dart), headers (request\_headers.dart), URL parameters (request\_params.dart), and gRPC-specific metadata and parameters (request\_metadata\_grpc.dart, request\_parameters\_grpc.dart). The main pane controllers (request\_pane\_rest.dart, request\_pane\_graphql.dart, request\_pane\_grpc.dart, request\_pane\_ws.dart) now compose these smaller widgets, creating a more modular structure for editing REST, GraphQL, gRPC, and WebSocket requests.
_lib/screens/home\_page/editor\_pane/details\_card/request\pane · high confidence
Unified response pane with dedicated real-time views for WebSocket, MQTT, and gRPC
The Request Details Card now uses a single ResponsePane widget that dynamically renders the appropriate view based on the request type. For WebSocket, MQTT, and gRPC requests, the pane displays a real-time event stream log (RealtimeEventStreamView) that supports topic filtering, message expansion, and metadata inspection, replacing the previous static response display. HTTP and GraphQL requests continue to use the standard response details view with headers and body tabs. This change consolidates the presentation layer for all protocol types within the editor pane.
_lib/screens/home\_page/editor\_pane/details\card · high confidence
Fixes
Refactor WebSocket request pane into modular widgets with improved message history UI
The WebSocket request pane has been split into dedicated widget files to improve code organization and UI performance. The new \WsConnectionSettings\ widget provides a dedicated tab for configuring auto-reconnect, low-level automatic pings, and repeating message heartbeats. The \WsMessageEditor\ widget now manages the message composer and template management, while the \WsRecentlySent\ widget handles the history strip. This separation ensures the composer does not rebuild unnecessarily when new messages arrive. The history strip now deduplicates messages by payload, displays a send count (e.g., '×N') for repeated messages, and includes a 'View full message' button to see the complete text of long payloads that are truncated in the card view.
_lib/screens/home\_page/editor\_pane/details\_card/request\pane/ws · high confidence
Test coverage
Added comprehensive test suite for curl\_parser; Added comprehensive unit tests for utility functions; Added comprehensive widget tests for the terminal screen; Added desktop integration tests for Environment Manager, Request Editor, and Request History; Added empty test suite for apidash\_core; Added golden tests for JSON Explorer UI components; Added initial test file for better\_networking package; Added integration test driver entry point; Added integration tests for gRPC, WebSocket, and MQTT connection management; Added model unit tests for environment, history, HTTP, MQTT, and gRPC models; Added test coverage for DashBot services; Added test coverage for multiple code generation targets; Added test helper extensions for WidgetTester; Added test infrastructure and constants; Added test suite for Insomnia collection parsing and utilities; Added tests for DashBot UI, prompts, and WebSocket/MQTT task buttons; Added tests for DashBot chat viewmodel AI flows and history integration; Added tests for GenAI request utilities, model management, and available models; Added tests for GraphQL, REST, and SSE request handling; Added tests for HAR form-data parsing edge cases; Added tests for HAR parsing and utility functions; Added tests for MQTT request pane, WebSocket recently sent, and gRPC request components; Added tests for Postman collection parsing and utility functions; Added tests for StringExtensions; Added tests for curl import and utility functions; Added tests for terminal filter menu, models, and log tiles; Added unit and widget tests for DashBot utility functions; Added unit and widget tests for genai package; Added unit tests for ChatFailure class; Added unit tests for ChatRemoteRepository; Added unit tests for DashBot providers; Added unit tests for Dashbot core components; Added unit tests for FormDataModel and NameValueModel; Added unit tests for HttpClientManager and OAuthCallbackServer; Added unit tests for Java HTTP client code generators; Added unit tests for MapExtensions; Added unit tests for ResponseSemanticAnalyser; Added unit tests for auth and HTTP request/response models; Added unit tests for authentication utilities and models; Added unit tests for better\_networking utility functions; Added unit tests for common UI widgets; Added unit tests for genai agentic engine and model providers; Added unit tests for genai model classes; Added unit tests for request consolidation and import logic; Added widget tests for DashBot UI components; Added widget tests for DashBot action buttons; Added widget tests for Dashbot pages and routing; Added widget tests for authentication field components; Added widget tests for the AI Request History screen components; Added widget tests for the editor pane components; Added widget unit tests for buttons, cards, dialogs, and previewers; Expanded provider test coverage for collection, UI, and terminal state; Initial test coverage for apidash\_design\_system; New integration test infrastructure for environment and request workflows.
Dependencies
API Dash initializes as a Flutter monorepo with 11 workspace packages
The project is now structured as a Flutter monorepo using Melos, defining a root \pubspec.yaml\ and 11 child packages (\apidash\_core\, \apidash\_design\_system\, \better\_networking\, \curl\_parser\, \genai\, \har\, \insomnia\_collection\, \json\_explorer\, \json\_field\_editor\, \multi\_trigger\_autocomplete\_plus\, \postman\, and \seed\). The root application (\apidash\) depends on these internal packages alongside external libraries such as \flutter\_js\, \ollama\_dart\, \mqtt\_client\, \fvp\, and \just\_audio\. The workspace enforces a minimum Dart SDK of 3.11.0 and Flutter 3.41.2, with code generation handled by \build\_runner\ and \freezed\ across the packages.
(dependencies) · high confidence
Housekeeping
Add GSoC 2026 proposal documentation for Agentic API Testing, Multimodal AI Evaluation, Generative UI, and CLI/MCP support; Added Postman collection parsing example.
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 51 → 53 (+1.6)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 70 → 70 (+0.0)
- Architecture 98 → 98 (+0.0)
- Maturity 70 → 78 (+8.1)
- Readiness 50 → 54 (+4.3)
- Security 37 → 35 (-2.2)
- Domain Modelling 100 → 100 (+0.0)
- Performance 78 → 100 (+22.3)
Resolved (21)
- Change coupling clique: request_form_data.dart, request_headers.dart, request_params.dart (lib/screens/home_page/editor_pane/details_card/request_pane/request_form_data.dart)
- Documentation: no installation or build instructions (README.md)
- Documentation: no project overview (README.md)
- Duplicated block (10 lines × 2) (lib/services/connection_manager.dart)
- Duplicated block (11 lines × 2) (lib/screens/history/history_widgets/his_request_pane.dart)
- Duplicated block (12–13 lines × 2) (packages/apidash_core/lib/import_export/har_io.dart)
- Duplicated block (14 lines × 2) (lib/screens/history/history_widgets/his_request_pane.dart)
- Duplicated block (16 lines × 2) (lib/widgets/editor.dart)
- Duplicated block (16 lines × 7) (doc/gsoc/2025/codes/example4.dart)
- Duplicated block (16–17 lines × 2) (packages/apidash_core/lib/import_export/insomnia_io.dart)
- Duplicated block (18 lines × 7) (doc/gsoc/2025/codes/example4.dart)
- Duplicated block (27 lines × 6) (doc/gsoc/2025/codes/example4.dart)
- Duplicated block (9 lines × 3) (lib/models/settings_model.dart)
- Duplicated block (9–10 lines × 2) (lib/models/settings_model.dart)
- Edited copy of a member (18 corresponding lines) (lib/models/settings_model.dart)
- Hotspot: lib/models/settings_model.dart (lib/models/settings_model.dart)
- Hotspot: lib/screens/settings_page.dart (lib/screens/settings_page.dart)
- No ADRs found
- Off-boarding risk: anonymized user #1
- Off-boarding risk: anonymized user #2
- …and 1 more
New (56)
- Change coupling: request_headers.dart ↔ request_params.dart (lib/screens/home_page/editor_pane/details_card/request_pane/request_headers.dart)
- Duplicated block (10 lines × 2) (lib/services/connection_manager.dart)
- Duplicated block (11–12 lines × 2) (lib/dashbot/providers/chat_viewmodel.dart)
- Duplicated block (12–13 lines × 2) (packages/apidash_core/lib/import_export/har_io.dart)
- Duplicated block (16 lines × 2) (lib/widgets/editor.dart)
- Duplicated block (16–17 lines × 2) (packages/apidash_core/lib/import_export/insomnia_io.dart)
- Duplicated block (18 lines × 7) (doc/gsoc/2025/codes/example4.dart)
- Duplicated block (27 lines × 6) (doc/gsoc/2025/codes/example4.dart)
- Duplicated block (9 lines × 2) (lib/codegen/go/http.dart)
- Edited copies of one member (3 members, 12+ corresponding lines) (packages/apidash_core/lib/import_export/har_io.dart)
- Edited copies of one member (3 members, 17+ corresponding lines) (lib/dashbot/prompts/dashbot_prompts.dart)
- Edited copies of one member (3 members, 17+ corresponding lines) (lib/providers/collection_providers.dart)
- Edited copies of one member (3 members, 55+ corresponding lines) (packages/multi_trigger_autocomplete_plus/example/lib/src/options/emoji_autocomplete_options.dart)
- Edited copies of one member (3 members, 93+ corresponding lines) (lib/codegen/rust/actix.dart)
- Edited copies of one member (4 members, 12+ corresponding lines) (lib/widgets/popup_menu_codegen.dart)
- Edited copies of one member (5 members, 19+ corresponding lines) (lib/dashbot/prompts/dashbot_prompts.dart)
- Edited copy of a member (10 corresponding lines) (lib/dashbot/widgets/dashbot_action_buttons/dashbot_add_test_button.dart)
- Edited copy of a member (10 corresponding lines) (lib/dashbot/widgets/dashbot_action_buttons/dashbot_select_operation_button.dart)
- Edited copy of a member (11 corresponding lines) (lib/dashbot/providers/chat_viewmodel.dart)
- Edited copy of a member (11 corresponding lines) (lib/providers/history_providers.dart)
- …and 36 more
Changes since last survey
- 1 commits — 1 feature/other, 0 fixes
By area
- (repo) — 1 commit
Notable commits
- change: Merge pull request #1880 from anshxs/resolve-issue-1879-mqtt-disconnect-on-remove
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
foss42/apidash was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit f9f8b61615f18304c640d0c0f2d98a9924c196a9 — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.57+preprod-8ebfb01cf4c0.