Skip to content
CAI
Software that uses CAICheck a score

apache/flink-agents

59.3

Adequate · 9 November 2026

109.7k

lines of production code

Java

with Python

9

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Amazon Bedrock embedding model integration

Users can now connect to Amazon Bedrock to generate text embeddings using the Amazon Titan Text Embeddings V2 model. This integration allows configuring the AWS region, model ID, embedding dimensions, and concurrency settings, and automatically tracks token usage metrics for billing and monitoring.

integrations/embedding-models/bedrock · high confidence

Add Amazon OpenSearch and S3 Vectors vector store integrations

Users can now persist and query vector embeddings using Amazon OpenSearch (including OpenSearch Serverless) and Amazon S3 Vectors. The OpenSearch integration supports both IAM (SigV4) and basic authentication, allows configuration of index names, vector/content field names, and AWS regions, and maps vector store collections to OpenSearch indices. The S3 Vectors integration connects to an S3 Vectors bucket and index, supporting document upserts, metadata filtering, and similarity search with relevance scores.

integrations/vector-stores/opensearch · high confidence

Add Anthropic chat model integration with native structured output support

Users can now integrate with the Anthropic Chat service via a new Java-based connection class. This integration supports standard chat parameters (API key, timeout, retries) and introduces native structured output support for specific Claude model generations (e.g., Claude Opus 4.6+, Sonnet 5, and Mythos Preview), allowing for more reliable schema-constrained responses without fallback to prompt engineering.

flink-agents-integrations-chat-models-anthropic · high confidence

Add ChromaDB vector store integration with Cloud support

Introduces a new ChromaVectorStore implementation for the Flink Agents vector store API, enabling semantic search capabilities using ChromaDB. This integration supports multiple connection modes including in-memory, persistent storage, server-based connections, and Chroma Cloud (via API key). The implementation includes thread-safe client initialization to handle concurrent access and automatically manages collection creation, providing a seamless way to store and query vector embeddings within Flink Agents applications.

_python/flink\_agents/integrations/vector\stores/chroma · high confidence

Add DashScope and Ollama chat model integrations with native structured output

Users can now connect to DashScope and Ollama chat models via new integration modules. Both integrations support native structured output for Pydantic models, allowing for reliable schema-constrained responses without prompt engineering fallbacks. The DashScope integration specifically targets Qwen3.7-Max family models for native JSON schema support, while the Ollama integration enables structured output for any model served by a compatible server.

_python/flink\_agents/integrations/chat\models · high confidence

Add DashScope and OpenAI embedding model integrations

Users can now generate text embeddings using DashScope or OpenAI models within Flink Agents. This change introduces new integration modules (\dashscope\_embedding\_model.py\ and \openai\_embedding\_model.py\) that implement the standard embedding model interface, allowing connections to these external APIs with support for configuration options like model selection, timeout, and token usage tracking.

_python/flink\_agents/integrations/embedding\models · high confidence

Add Elasticsearch vector store integration for Java agents

Users can now store and retrieve vector embeddings using Elasticsearch as a backend for Flink Agents. This new Java implementation supports approximate nearest neighbor (KNN) searches, configurable vector dimensions, and optional filtering via Elasticsearch DSL queries. It also handles index management and supports both basic authentication and API key-based security for connecting to Elasticsearch clusters.

flink-agents-integrations-vector-stores-elasticsearch · high confidence

Add Google Gemini chat model integration

Users can now connect to Google Gemini models via a new built-in integration. This adds the GeminiChatModelSetup and GeminiChatModelConnection classes, allowing configuration of the model (defaulting to gemini-3.1-pro-preview), temperature, max output tokens, and tool bindings. The integration handles message conversion, tool call synthesis, and supports native structured output for compatible models like gemini-2.5-flash.

flink-agents-integrations-chat-models-gemini, integrations/chat-models/gemini · high confidence

Add IBM watsonx.ai chat model integration

Users can now connect to IBM watsonx.ai for chat completions. The integration supports configuring the API URL, project or space ID, and authentication via API key or static token. It includes native structured output support (generating JSON schemas from POJOs), reasoning extraction from model responses, and standard chat parameters like temperature and max tokens.

integrations/chat-models/watsonx · high confidence

Add IBM watsonx.ai chat model integration with native structured output support

Users can now connect Flink Agents to IBM watsonx.ai via a new chat model integration. This addition enables sending chat messages to watsonx models (defaulting to ibm/granite-4-h-small) and supports native structured output by passing JSON schema definitions directly to the provider, ensuring responses conform to specified Pydantic models. The integration handles message conversion, tool calling, and includes retry logic for transient errors.

_python/flink\_agents/integrations/chat\models/watsonx · high confidence

Add Java support for Model Context Protocol (MCP) integrations

This change introduces the Java implementation for MCP integrations within the Flink Agents framework. It adds new classes to define and execute MCP tools (MCPTool) and prompts (MCPPrompt), allowing agents to dynamically fetch and use tools and prompts from MCP servers. The update also includes authentication support via ApiKeyAuth, BasicAuth, and BearerTokenAuth, enabling secure connections to MCP servers that require API keys, basic credentials, or OAuth bearer tokens.

flink-agents-integrations-mcp · high confidence

Add Java wrappers for Python-based agent resources

This change introduces a set of Java bridge classes in the Flink Agents plan layer that allow Java code to interact with Python implementations of key agent resources. Specifically, it adds wrappers for ChatModel, EmbeddingModel, DecisionModel, VectorStore (with collection management), MCP Server, MCP Tools, and MCP Prompts. These classes delegate operations to the underlying Python objects via the Pemja bridge, enabling cross-language resource usage where Java agents can consume Python-defined models, tools, and prompts.

plan/src/main/java/org/apache/flink/agents/plan/resource · high confidence

Add Milvus vector store integration

Users can now store and query vector embeddings using Milvus as a backend for Flink Agents. This new integration provides a \MilvusVectorStore\ implementation that supports dense-vector similarity search, collection management (create, drop, load), and configurable schema options such as vector dimensions, metric types, and index settings. It also allows indexing specific metadata fields for filtering and supports authentication via token or basic credentials.

_python/flink\_agents/integrations/vector\stores/mem0 · high confidence

Add OpenAI and Azure OpenAI chat model integrations

Users can now connect to OpenAI and Azure OpenAI services via three new Java chat model connections: OpenAICompletionsConnection (using the Chat Completions API), OpenAIResponsesModelConnection (using the new Responses API), and AzureOpenAIChatModelConnection (using the Azure SDK). These integrations support native structured output for specific model families, allow configuration of timeouts, retries, and custom headers, and handle Azure-specific URL path modes and API versions.

flink-agents-integrations-chat-models-openai · high confidence

Add OpenAI embedding model integration

Users can now generate text embeddings using the OpenAI Embeddings API via a new Java-based connection class. This implementation supports configuration of the API key, base URL, request timeout, and retry count, as well as optional organization and project IDs. It allows per-request specification of the model, encoding format (float or base64), dimensions, and user identifier, while surfacing token usage statistics returned by the API.

_flink-agents-integrations-embedding-models-openai, python/flink\_agents/integrations/chat\models/vllm · high confidence

Add OpenAI embedding model integration for Java

Users can now configure and use OpenAI embedding models within the Java agent framework. This change introduces the \OpenAIEmbeddingModelSetup\ and \OpenAIEmbeddingModelConnection\ classes, allowing users to specify connection details (such as API key, base URL, organization, and project), model selection, and embedding parameters like encoding format, dimensions, and user identity. The implementation includes validation for required fields and numeric options, ensuring that configuration errors are caught early during setup rather than at runtime.

flink-agents-integrations-embedding-models-ollama, integrations/embedding-models/ollama · high confidence

Add RAG agent example with Ollama and ChromaDB

A new example RAG (Retrieval-Augmented Generation) agent has been added to the Flink Agents examples. This agent demonstrates a workflow where it receives a user query, retrieves relevant context from a ChromaDB vector store using an Ollama embedding model, and then generates a response using an Ollama chat model. The implementation includes setup for the embedding model, vector store, and chat model, along with actions to process input, handle context retrieval, and output the final response.

_python/flink\agents/examples/rag/agents · high confidence

Add built-in Ollama embedding model integration

Users can now generate text embeddings using a local Ollama server via the new \OllamaEmbeddingModelConnection\ and \OllamaEmbeddingModelSetup\ classes. This integration allows connecting to an Ollama instance (defaulting to localhost:11434) and supports configuration options such as model selection, truncation behavior, and request timeouts, enabling local embedding generation without external cloud dependencies.

_python/flink\_agents/integrations/embedding\models/local · high confidence

Add built-in support for Azure OpenAI Chat Model

Users can now connect Flink Agents to Azure OpenAI via a new \AzureOpenAIChatModelConnection\. This integration supports native structured output for specific GPT and o-series models by leveraging Azure's JSON schema response format, and includes configuration options for API keys, endpoints, timeouts, and retries.

_python/flink\_agents/integrations/chat\models/azure · high confidence

The Flink 1.20 agents runtime now includes an \OperatorUtils\ helper that allows setting the chaining strategy (e.g., ALWAYS, NEVER, HEAD) on stream operators. This utility enables more granular control over how operators are chained together during execution, which can impact performance and resource usage in streaming jobs. A corresponding test suite verifies the correct application of these strategies across different operator types.

dist/flink-1.20 · high confidence

Anthropic Chat Model integration with structured output and tool support

This change introduces the Python integration for the Anthropic chat model within Flink Agents. It enables users to connect to Anthropic's API, supporting tool use via the standard tool metadata conversion and handling of multi-modal content blocks. The integration also implements native structured output support for specific Claude model generations (such as Claude 4.5+ and Mythos) and manages model-specific constraints like prefilling restrictions, ensuring robust interaction with the Anthropic API. Also in this area: ReAct agent supports native structured output and constructor-level skills; Refactor ChatMessage and separate model invocation results; Multimodal chat messages and explicit terminal failure handling.

_python/flink\_agents/integrations/chat\models/anthropic · high confidence

CLI tool for visualizing agent execution traces

A new command-line interface has been added to Flink Agents, allowing users to reconstruct and view trace trees from Event Log files. The \trace\_tree\ module reads event logs (supporting both current and legacy formats) and outputs a structured representation of the agent's execution lineage in either text or JSON format, enabling users to inspect the sequence of actions and events that occurred during an agent run.

_python/flink\agents/cli · high confidence

Checkpoint-aligned Kafka action-state cleanup and durable execution infrastructure

The runtime now supports checkpoint-aligned cleanup of Kafka action-state topics to prevent unbounded storage growth, introducing a durable two-phase commit protocol (COMMITTED then APPLIED) managed by the new KafkaActionStateCleanupCoordinator and KafkaActionStateCleanupPlan. This ensures that state deletion boundaries are safely derived from union recovery markers in checkpoints and applied idempotently. Alongside this, the runtime introduces fine-grained durable execution via the CallResult class, which persists the success or failure of individual durable calls to enable recovery without re-execution, and adds the ActionStateKeyEncoder to manage deterministic key encoding for keyed state. These changes also include supporting infrastructure such as the RunnerContextImpl for action execution context, CachedMemoryStore for memory state, and feedback/logging components copied from Flink Statefun to support the new execution and observability models.

flink-agents-runtime · high confidence

Declarative YAML API for declaring agents and resources

Users can now define Flink Agents, their actions, tools, prompts, and associated resources (such as chat models, embedding models, vector stores, and MCP servers) using a declarative YAML format. This new API introduces short aliases for resource implementations (e.g., 'openai', 'ollama', 'chroma') that resolve to specific Python or Java classes, simplifying configuration. It supports cross-language resource declarations, allowing Java resources to be referenced from Python YAML files and vice versa, and enables the definition of internal sub-agents within the same document. The loader validates the structure, ensuring prompts are non-empty and function references follow the required module:qualname format.

_python/flink\agents/api/yaml · high confidence

Embedding models now report token usage metrics

The embedding API now exposes token usage metadata (prompt and total tokens) alongside embedding results. Users can access this information via the new \EmbeddingResult\ wrapper and \EmbeddingTokenUsage\ class, which are returned by the new \embedWithUsage\ methods on \BaseEmbeddingModelSetup\ and \BaseEmbeddingModelConnection\. This change also introduces \EmbeddingModelUtils\ to handle the conversion of cross-language (Python) embedding responses into typed Java objects, ensuring that usage data is correctly parsed and propagated.

api/src/main/java/org/apache/flink/agents/api/embedding · high confidence

This change introduces the OllamaChatModelConnection, a new Java integration that allows Flink Agents to interact with local Ollama instances. Users can now configure an Ollama endpoint and leverage features such as tool calling, structured output via JSON schema generation, and multimodal support including image handling. The implementation adapts the generic Flink Agents chat model interface to Ollama's specific API, including handling of tool schemas and message roles.

flink-agents-integrations-chat-models-ollama · high confidence

The Python Flink Agents library is now available, introducing the core \flink\_agents\ package and a companion \examples\ subpackage. This initial release establishes the foundational structure for building and running Flink-based agents in Python, providing the necessary entry points and licensing headers to begin development.

_python/flink\_agents, python/flink\agents/examples · high confidence

Introduce AGENT resource type and sub-agent invocation API

The API now supports defining and invoking sub-agents as first-class resources. A new AGENT type is added to the ResourceType enum, and the SubagentSetup class allows agents to declare nested sub-agents. Invocations are managed through SubagentFuture and SubagentFutures, which provide asynchronous execution, cancellation, and grouping capabilities. Results are captured in SubagentResult, designed to be serializable for durable execution and failover recovery, allowing callers to inspect success or error states without relying on exception propagation.

api/src/main/java/org/apache/flink/agents/api/resource · high confidence

Introduce Amazon Bedrock chat model integration with native structured output support

Users can now connect to Amazon Bedrock via the Converse API to invoke supported models (such as Claude, Mistral, and Gemma variants) directly within Flink Agents. This integration handles authentication via the default AWS credentials chain, supports tool calling, and automatically applies native structured output for models that support it, eliminating the need for manual JSON parsing or schema enforcement on the client side.

integrations/chat-models/bedrock/src/main · high confidence

Users can now integrate with the Anthropic Messages API via a new \AnthropicChatModelSetup\ and supporting utilities. This addition enables agents to send user messages containing images (JPEG, PNG, GIF, WebP) and documents (PDFs or plain text via Base64 or URL) to Anthropic models. The setup allows configuration of the model (defaulting to \claude-sonnet-4-6\), temperature, max tokens, strict tool adherence, and JSON prefilling, while handling the conversion of Flink Agents' internal message structures into Anthropic SDK types.

integrations/chat-models/anthropic/src/main · high confidence

Introduce Bash tool with AST-based command validation

The Python Flink Agents plan now includes a Bash tool that executes shell commands using a strict, AST-based validator powered by tree-sitter-bash. This validator enforces an allowlist of permitted commands and directories, while actively blocking dangerous shell constructs such as command substitution ($(), backticks), process substitution, subshells, loops, and file redirections (allowing only safe file-descriptor duplication/closure). It also prevents execution-changing environment variable assignments (e.g., PATH, LD\_PRELOAD) and standalone variable assignments, ensuring that only safe, whitelisted operations are permitted.

_python/flink\agents/plan/tools/bash · high confidence

Introduce Event model with cross-language serialization and durable execution support

The Python API now includes a unified Event class that supports both direct instantiation with arbitrary attributes and subclassing for typed events. This model handles cross-language compatibility by normalizing field names (e.g., upstreamEventId) and serializing PyFlink Row objects for JSON compatibility. It also integrates with the new durable execution framework, allowing agents to persist state across checkpoints and recover from failures, as demonstrated by the new e2e tests for checkpoint recovery and durable execute operations.

flink-agents · high confidence

The API now exposes a new metrics subsystem for monitoring agent actions. Users can access metric groups via the new FlinkAgentsMetricGroup interface, which supports hierarchical grouping (including key-value pairs for model and action dimensions) and provides access to counters, meters, histograms, and gauges. A new UpdatableGauge interface extends the standard Gauge to allow runtime value updates, standardizing on String values to ensure consistency across Python and Java interactions.

api/src/main/java/org/apache/flink/agents/api/metrics · high confidence

Introduce FunctionTool for executable function definitions

The \python/flink\_agents/plan/tools\ module now provides the \FunctionTool\ class, which wraps Python or Java functions to make them executable tools. This component handles the automatic derivation of tool metadata (such as name, description, and argument schemas) from function signatures and docstrings, and supports parameter injection via \InjectedArg\ for both local Python functions and remote Java functions bridged through a resource adapter.

_python/flink\agents/plan/tools · high confidence

Introduce Java API for Long-Term Memory

This change adds the Java-side API for long-term memory management, introducing the BaseLongTermMemory interface and the MemorySet class to allow agents to store, retrieve, and search persistent memory items. It includes configuration options for the Mem0 backend (chat model, embedding model, and vector store) and defines the MemorySetItem data structure, enabling users to integrate semantic memory capabilities into their Flink agents.

api/src/main/java/org/apache/flink/agents/api/memory · high confidence

This change adds the core Java API classes for defining and running Flink Agents, including the AgentsExecutionEnvironment for configuring inputs from DataStreams, Tables, or lists, and the AgentBuilder for chaining agent configurations and producing outputs. It introduces a unified Event model with type-based routing, attachments, and lineage tracking, along with specific event types (InputEvent, OutputEvent) and a centralized EventType constant registry. Additionally, it provides a RetryExecutor utility with configurable backoff for remote calls and an EventContext for runtime event observation.

api/src/main/java/org/apache/flink/agents/api · high confidence

Introduce Java Agent API with ReAct Agent, execution options, and output schema support

This change introduces the core Java API for defining and executing agents in Flink Agents. It adds the base Agent class for registering actions and resources, and the built-in ReActAgent which supports skills, prompt formatting, and structured output via JSON Schema rendering for RowTypeInfo. It also provides AgentExecutionOptions to configure parallel execution, async behavior, and short-term memory TTL policies, along with supporting classes for schema serialization and TTL visibility.

api/src/main/java/org/apache/flink/agents/api/agents · high confidence

Introduce Java AgentPlan and configuration model with cross-language function support

The plan module now includes the core Java model for defining and serializing agent workflows. AgentPlan serves as the central structure, holding actions, resource providers, and configuration, and supports JSON serialization via custom Jackson serializers. AgentConfiguration provides a key-value store for agent settings. To enable cross-language execution, the plan layer introduces Function, JavaFunction, and PythonFunction classes, allowing the plan to represent and serialize both Java methods and Python functions for later invocation. Additionally, trigger conditions for actions can now be defined using CEL expressions, validated at plan time, and parsed by a shared dialect.

plan/src/main/java/org/apache/flink/agents/plan · high confidence

Introduce Java Model Context Protocol (MCP) integration

This change adds initial support for connecting to Model Context Protocol (MCP) servers within the Java agent framework. It introduces the \MCPServer\ resource class, which allows users to configure server endpoints, authentication methods (Bearer token, Basic, or API key), timeouts, and retry policies via resource descriptors. The integration includes an \MCPContentExtractor\ utility to normalize various MCP content types (text, images, embedded resources) into Java-friendly objects, and an \Auth\ interface hierarchy to handle HTTP request authentication securely.

integrations/mcp/src/main · high confidence

Introduce Java Prompt API for template-based message generation

The Flink Agents Java API now includes a new \Prompt\ class and its \LocalPrompt\ implementation, allowing users to define templates using either plain text strings or sequences of chat messages. This API supports placeholder substitution (e.g., \{variable}\) in a single pass, enabling the dynamic generation of formatted text or structured chat message lists for use with language models.

api/src/main/java/org/apache/flink/agents/api/prompt · high confidence

This change adds the resource provider implementation classes in the plan module, enabling the agent framework to instantiate and manage resources at runtime. It introduces JavaResourceProvider and JavaSerializableResourceProvider to create Java-based resources (including serializable ones via Jackson), and PythonResourceProvider and PythonSerializableResourceProvider to bridge Python resources (such as ChatModels, EmbeddingModels, VectorStores, MCP servers, Prompts, and Tools) into the Java agent execution context. These providers carry the necessary metadata (module, class, arguments) to dynamically load and construct the appropriate resource objects when an AgentPlan is executed.

plan/src/main/java/org/apache/flink/agents/plan/resourceprovider · high confidence

Introduce Prompt abstraction for templating chat messages

This change adds a new \Prompt\ API under \python/flink\_agents/api/prompts\ that allows users to define and format chat templates. It includes a \LocalPrompt\ implementation that supports both plain text and sequence-of-messages templates, utilizing a custom \SafeFormatter\ (based on \re\ rather than Python's \Formatter\) to safely substitute variables without raising errors on missing keys. This enables users to create reusable prompt structures that can be formatted with dynamic arguments to generate \ChatMessage\ objects or raw strings.

_python/flink\agents/api/prompts · high confidence

This change introduces the initial Python API for Flink Agents, establishing the core abstractions for building and executing agents. It provides the \AgentsExecutionEnvironment\ for integrating agents with Flink DataStream and Table APIs, and defines the \AgentBuilder\ for configuring agent outputs. The API includes decorators like \@action\ for marking functions as agent actions and specific decorators for chat, decision, and embedding models. It also introduces data models for chat interactions (\ChatMessage\, \ChatResult\), function descriptors (\PythonFunction\, \JavaFunction\) for cross-language support, and a configuration system (\Configuration\, \AgentConfigOptions\) for managing runtime settings. Additionally, it defines the memory abstraction with \MemoryObject\ and \MemoryRef\ for short-term and sensory memory, along with metric groups for observability.

_python/flink\agents/api · high confidence

Introduce Python ChatModel API with structured output and token metrics

The Python API now includes a new \chat\_models\ module providing \BaseChatModelConnection\ and \BaseChatModelSetup\ abstractions, enabling developers to integrate with chat providers. This release adds explicit support for structured output via the \StructuredOutputStrategy\ enum (AUTO, NATIVE, PROMPT) and an \output\_schema\ parameter, allowing users to enforce response formats. It also introduces token usage metrics tracking (prompt and completion tokens) scoped to specific models and actions. Additionally, the API supports bridging to Java-based chat models through \JavaChatModelConnection\ and \JavaChatModelSetup\, facilitating cross-language resource usage.

_python/flink\_agents/api/chat\models · high confidence

Introduce Python Embedding Model abstraction and built-in Ollama support

This change adds a new \embedding\_models\ API module to the Python Flink Agents SDK, providing a standardized abstraction for text embedding models. It introduces \BaseEmbeddingModelConnection\ and \BaseEmbeddingModelSetup\ classes that allow users to configure and interact with embedding services, including a new built-in implementation for Ollama. The API supports tracking token usage metrics via \EmbeddingResult\ and \EmbeddingTokenUsage\, enabling users to monitor consumption when calling embedding functions. Tests are included to verify the correct handling of embedding results and token usage data.

_python/flink\_agents/api/embedding\models · high confidence

Introduce Python Tool API with parameter injection and declarative function tools

This change adds the \flink\_agents.api.tools\ module, providing a new Python API for defining and executing tools. Users can now create declarative \FunctionTool\ instances from Python callables, which support automatic injection of parameters from agent configuration, sensory memory, or short-term memory via the \InjectedArg\ and \ToolParameterSource\ classes. The API includes a \Tool\ base class with metadata handling, a \ToolResponse\ dataclass for reporting execution results and errors, and a \ToolExecutionMetadataProvider\ abstraction for capturing execution details.

_python/flink\agents/api/tools · high confidence

Introduce Python Vector Store API with built-in Chroma support

The Python API now includes a dedicated vector store module, providing a unified interface for semantic search operations. This change introduces the \BaseVectorStore\ abstract class and associated data models (\VectorStoreQuery\, \Document\, \VectorStoreQueryResult\), enabling developers to interact with vector databases consistently. A built-in implementation for Chroma is provided, allowing users to perform semantic searches with configurable limits and metadata filters. The API also supports automatic embedding generation via integrated embedding models, simplifying the setup process for vector-based retrieval tasks.

_python/flink\_agents/api/vector\stores · high confidence

Introduce Python agent configuration and resource provider abstractions

The \python/flink\_agents/plan\ module now provides the core abstractions for managing agent configuration and resources. Users can define and load agent settings via \AgentConfiguration\, which supports reading from YAML files and offers typed accessors for configuration values. Additionally, the module introduces \ResourceProvider\ implementations (\PythonResourceProvider\, \PythonSerializableResourceProvider\, and \JavaResourceProvider\) that handle the instantiation and deserialization of resources at runtime, including specific mappings for Java-based resources like ChatModels and VectorStores.

_python/flink\agents/plan · high confidence

Introduce Python agent skill loading from local, URL, and package sources

Users can now load agent skills in Python from local directories, HTTPS URLs (with optional SHA-256 digest pinning), and installed Python packages. The runtime materializes non-local sources into temporary directories and provides a registry-based source system that maps schemes (local, url, package) to repository implementations, enabling flexible skill discovery and activation.

_python/flink\agents/runtime/skill · high confidence

Introduce Python runtime infrastructure for durable agent execution

The \python/flink\_agents/runtime\ package is introduced, providing the core execution engine for Flink Agents in Python. This includes durable execution support that persists call states and exceptions (including those that cannot be pickled) to ensure fault tolerance, and a sub-agent framework supporting both deferred and asynchronous invocation modes for internal and remote sub-agents. The runtime also implements cross-language resource bridges for short-term memory and metrics, and manages Python dependency generations to handle dynamic module updates within the Pemja interpreter.

_python/flink\agents/runtime · high confidence

Introduce Python wrappers for Java-backed agent resources

The \python/flink\_agents/plan/resource\ module now provides Python-side wrappers for Java-implemented resources, enabling Python agents to interact with Java chat models, embedding models, vector stores, tools, and prompts. This includes \JavaChatModelConnection\ and \JavaChatModelSetup\ for delegating chat operations to Java, \JavaEmbeddingModelConnection\ and \JavaEmbeddingModelSetup\ for embedding generation, \JavaVectorStore\ for vector operations, and \JavaTool\/\JavaPrompt\ wrappers. A \JavaResourceAdapter\ protocol and \JavaResourceContextWrapper\ facilitate the bridge, handling conversions for chat messages, documents, and skill resolution between the Python and Java runtimes.

_python/flink\agents/plan/resource · high confidence

Introduce built-in Java agent actions with durable execution and parallel tool calls

This change adds the core built-in action implementations for the Flink Agents plan in Java, including Action, ChatModelAction, ContextRetrievalAction, and ToolCallAction. These actions provide the execution logic for chat requests, context retrieval (RAG), and tool calls, leveraging the engine's durable execution machinery to ensure resilience. A key behavioral addition is support for parallel tool call execution, allowing multiple tool invocations to run concurrently when configured, while also handling tool parameter injection and error strategies. The implementation includes model routing capabilities within ChatModelAction and ensures that interrupted or cancelled calls are not retried or persisted, improving reliability during agent cancellation.

plan/src/main/java/org/apache/flink/agents/plan/actions · high confidence

Introduce built-in ReAct Agent with structured output and skills support

The Python API now includes a built-in ReActAgent class that enables users to define agents leveraging LLM function calling capabilities. Users can configure the agent with a chat model, custom prompts, and an output schema (Pydantic models or Flink RowTypeInfo) to enforce structured responses. The agent automatically handles schema rendering into prompts, supports native structured output when the chat model connection allows it, and integrates with a skills system to expose tools to the LLM. This change also introduces the base Agent class for defining custom agent logic via decorators or programmatic action/resource registration, along with comprehensive tests for schema rendering and agent behavior.

_python/flink\agents/api/agents · high confidence

Introduce built-in actions for chat, context retrieval, and tool result handling

This change adds new built-in action components to the Python agent plan, enabling core agent capabilities. The \chat\_model\_action.py\ file implements the logic for invoking chat models, including handling tool calls, managing retry strategies, and ensuring checkpoint safety by serializing context in sensory memory. The \context\_retrieval\_action.py\ file introduces a built-in action for processing context retrieval requests, supporting both synchronous and asynchronous execution depending on the Flink version and configuration. Additionally, \tool\_result\_utils.py\ provides utilities to normalize sub-agent results into JSON-compatible formats for safe state binding and reporting. These actions form the foundation for executing chat interactions and retrieving context within the agent framework.

_python/flink\agents/plan/actions · high confidence

Introduce dedicated event types for chat, tools, context retrieval, and memory

The \python/flink\_agents/api/events\ module now exposes a comprehensive set of typed event classes to represent agent lifecycle and interaction details. Users can now observe specific operational milestones through \ChatRequestEvent\ and \ChatResponseEvent\ (which includes retry counts and failure status), \ToolRequestEvent\ and \ToolResponseEvent\ (which track individual tool call successes and errors), and \ContextRetrievalRequestEvent\ and \ContextRetrievalResponseEvent\ for vector store interactions. Additionally, a full hierarchy of \MemoryEvent\ subclasses (covering short-term, sensory, and long-term memory operations) and \AgentRunBeginEvent\ provides granular observability into the agent's internal state and memory usage.

_python/flink\agents/api/events · high confidence

Introduce durable action state persistence with Kafka and Fluss backends

The runtime now persists agent action state to durable external backends (Kafka or Fluss) to enable fine-grained recovery and exactly-once semantics. This change introduces the \ActionStateStore\ interface and its implementations, along with \ActionStateSerde\ for serializing state (including memory updates via a versioned Kryo envelope) and \ActionStateKeyEncoder\ for generating stable, type-preserving keys. It also adds \ResourceCache\ for lazy, thread-safe resolution of agent resources (including Python MCP tools and prompts) and \CompileUtils\ to bridge Flink DataStreams with the agent runtime, including a safety check that rejects incompatible Flink batch configurations.

runtime/src/main · high confidence

Introduce long-term memory interface and Mem0 support

This change introduces a new long-term memory API for Flink Agents, allowing actions to persist and retrieve context across sessions. It provides a \MemorySet\ interface scoped to individual actions to ensure correct partitioning, supports vector-store-based implementations, and adds specific configuration options for the Mem0 backend (chat model, embedding model, and vector store). Users can now add, search, get, and delete memory items within the context of their agent actions.

_python/flink\agents/api/memory · high confidence

Introduce long-term memory interface and event attachment utilities

This change adds the internal foundation for long-term memory observability and event attachment handling within the Flink Agents runtime. It introduces the \InternalBaseLongTermMemory\ abstract class, which extends the public long-term memory interface to expose internal configuration methods for controlling observation recording (update, get, and search) and context switching for data isolation. Additionally, it adds \event\_attachment\_utils.py\ to manage the storage and loading of event attachments in sensory memory, ensuring that attachments are validated, stored as references, and correctly resolved before Python actions execute.

_python/flink\agents/runtime/memory · high confidence

Introduce pluggable in-chat model routing with LLM-judge and rule-based strategies

Users can now configure a ModelRouter to select among multiple chat models for a single request using declarative strategies. The API provides built-in rule-based routing (regex matching against the latest user message) and a framework-managed LLM-as-judge strategy, where a designated judge model evaluates the conversation and selects a candidate. Users can also supply a custom CustomRoutingExecutor for pure selection logic. The router validates candidates and defaults at declaration time, supports abstention to fall back to a default model, and allows attaching human-readable descriptions to candidates to guide semantic routing decisions.

api/src/main/java/org/apache/flink/agents/api/chat/model/routing · high confidence

Introduce sub-agent invocation API and input schema generation

This change adds the core API components for defining and invoking sub-agents within the Flink Agents framework. It introduces the \SubagentSetup\ class, which allows developers to register sub-agents as \AGENT\ resources with descriptions and input schemas (automatically derived from Java types via Jackson or explicitly defined). The \InputSchemas\ utility handles the conversion of Java input types into JSON Schema, ensuring cross-language compatibility (e.g., aligning with Python/pydantic conventions for required fields and binary data). Additionally, new classes \SubagentFuture\, \SubagentFutures\, and \SubagentResult\ provide the mechanism for submitting invocations, handling asynchronous results, and managing success/failure states in a way that supports durable execution and failover recovery. Also in this area: Native structured output support and sub-agent resource wrapping.

api/src/main/java/org/apache/flink/agents/api/subagent · high confidence

Introduce unified Java Vector Store API

This change introduces a new, unified API for vector store integrations in Java, centered around the new \BaseVectorStore\ abstract class. It provides a consistent interface for adding, updating, and querying documents, including automatic embedding generation via configured models. The API supports a unified filter DSL for metadata equality matching, allows specifying target collections, and exposes store-specific arguments through \extraArgs\. Supporting types include \Document\ for content and metadata, \VectorStoreQuery\ for query parameters (mode, limit, filters), and \VectorStoreQueryResult\ for results. An optional \CollectionManageableVectorStore\ interface is also added for stores that support collection lifecycle management.

api/src/main/java/org/apache/flink/agents/api/vectorstores · high confidence

Introduce unified Trace Log API for agent execution tracing

The Agents API now replaces the legacy Event Log with a unified Trace Log system, providing a new set of classes in the logger package to configure and record execution traces. Users can now select specific entity types (events, actions, tools, LLMs, parsers, subagents) and control recording detail via the new TraceLogLevel (OFF, STANDARD, VERBOSE) and TraceLogScope (EVENT\_ONLY, ALL). The system supports two built-in output backends—SLF4J (default, outputting to the Flink Web UI) and FILE (writing to per-subtask log files)—configured via the new TraceLoggerConfig and TraceLoggerFactory.

api/src/main/java/org/apache/flink/agents/api/logger · high confidence

Introduce unified trace API for agent execution observability

The Flink Agents API now includes a new \trace\ package in both Java and Python that provides a unified interface for recording and reporting agent execution events. This change introduces the \ExecutionReporter\ interface and \ExecutionReporters\ helper utilities, allowing the framework to report the lifecycle (creation, start, success, failure) of internal calls such as LLM requests, tool invocations, parser operations, and subagent executions. The API defines shared entity types (e.g., \llm\, \tool\, \subagent\) and problem categories to standardize how these events are observed and consumed, replacing the previous event log mechanism with a more structured trace log format.

_api/src/main/java/org/apache/flink/agents/api/trace, python/flink\agents/api/trace · high confidence

This change adds a new configuration mechanism for Flink Agents, introducing a set of configuration options in the \AgentConfigOptions\ class. Users can now configure trace log output (SLF4J or file-based), action state store backends (Kafka or Fluss), and memory event generation. The Kafka backend options allow specifying bootstrap servers, topics, partitions, replication factors, and tombstone behavior for state pruning. The Fluss backend options include bootstrap servers, database/table names, bucket counts, and SASL authentication settings. Additionally, trace log targets can be configured with specific scopes and log levels, and condition evaluation failure strategies can be set to warn and skip or fail fast.

api/src/main/java/org/apache/flink/agents/api/configuration · high confidence

The API context package now exposes the core interfaces for durable action execution and in-memory data passing. Users can perform resilient, restart-safe operations via the new \RunnerContext.durableExecute\ and \durableExecuteAsync\ methods, which accept \DurableCallable\ instances that support optional reconciliation logic for in-flight tasks. Asynchronous calls can be composed into parallel batches using \RunnerContext.gather\, which leverages \DurableFuture\ handles. Additionally, the package introduces \MemoryObject\ and \MemoryRef\ to manage sensory and short-term memory, allowing actions to pass large data structures efficiently via lightweight, serializable references rather than copying values.

api/src/main/java/org/apache/flink/agents/api/context · high confidence

Introduces provider-neutral decision model API for typed model calls

Adds a new decision model API in both Java and Python that allows applications to send structured evidence and typed questions (predicate, choice, or score) to external AI providers. The API defines \BaseDecisionModelConnection\ and \BaseDecisionModelSetup\ resources to manage provider clients and model configurations, while \DecisionRequest\ and \DecisionResult\ handle the structured input and typed outputs (including probabilities, distributions, and refusals). This enables developers to integrate AI-driven decision logic into Flink agents using a consistent, provider-agnostic interface.

(repo-wide) · high confidence

Introduces rule-based and custom model routing with fallback support

The plan layer now supports advanced model routing strategies. Users can define rule-based routing using regex patterns to select models based on user input, or implement custom routing logic via the Java SPI. The system also introduces a fallback mechanism: if the primary routed model fails, the agent can automatically attempt other declared candidates. Routing decisions are tracked in observability metadata, including the selected model, reason, and any fallback attempts.

flink-agents-plan · high confidence

The plan serializer module now provides custom Jackson serializers and deserializers for AgentPlan, Action, and ResourceProvider objects. This enables the complete serialization and deserialization of agent plans to and from JSON, including the preservation of Java and Python function details, trigger conditions, configuration data, and resource provider implementations (Java and Python variants). Users can now persist and restore agent plans in a structured JSON format, facilitating cross-language compatibility and plan portability.

plan/src/main/java/org/apache/flink/agents/plan/serializer · high confidence

Java implementation of the Bash tool with AST-based security validation

A new Java-based Bash execution tool has been added to the Flink Agents plan module, mirroring the existing Python implementation. This tool allows agents to execute shell commands while enforcing strict security policies: it uses a tree-sitter-based AST validator to reject disallowed shell constructs, blocks file redirects (allowing only file-descriptor duplication/closure), and prevents assignments to dangerous environment variables (such as PATH, LD\, DYLD\). The tool also respects allowlists for specific commands and script directories, and supports configurable timeouts and working directories.

plan/src/main/java/org/apache/flink/agents/plan/tools/bash · high confidence

Mem0-based long-term memory integration

This change introduces a new long-term memory implementation for Flink Agents backed by Mem0, located in the \python/flink\_agents/runtime/memory/mem0\ module. It enables agents to persist and retrieve memory sets using Mem0's vector store capabilities, supporting both direct Chroma and Mem0-wrapped Chroma backends. The implementation includes observation recording to track memory operations (add, get, delete, search) scoped to specific actions and partitions, ensuring that memory interactions are observable and auditable within the agent runtime.

_python/flink\agents/runtime/memory/mem0 · high confidence

Multimodal message support with typed content blocks

The Java API for chat messages has been redesigned to support multimodal content. Messages now consist of an ordered list of typed content blocks rather than a single text string, introducing new classes for text, image, audio, video, and document content. Media payloads can be provided as inline Base64 data or external URLs, and the API includes strict validation and safe logging to prevent accidental exposure of sensitive media data or credentials in logs.

api/src/main/java/org/apache/flink/agents/api/chat/messages · high confidence

New API for defining and injecting tool parameters

The API now introduces a declarative tool parameter injection system, allowing tools to automatically receive values from framework sources like configuration, sensory memory, or short-term memory. This is enabled by new classes in the tools package: ToolParameterInjection and ToolParameterSource define the binding, while ToolParameterInjectionValidator ensures that injected arguments match the underlying Java method signatures. Additionally, the API layer now includes pure-data descriptors for cross-language function execution (JavaFunction and PythonFunction) and a FunctionTool class that wraps these descriptors, enabling users to define tools backed by Java methods or Python callables that are serialized for execution in the plan layer.

api/src/main/java/org/apache/flink/agents/api/tools · high confidence

New API function descriptors for cross-language actions

The API layer now introduces pure-data descriptors for cross-language function targets, enabling users to declare Java and Python functions directly in their agent plans. This change adds the \Function\ marker interface, along with \JavaFunction\ (identifying a Java method by class, name, and parameter types) and \PythonFunction\ (identifying a Python callable by module and qualified name). A utility class, \JavaFunctionUtils\, is also provided to resolve these descriptors back to Java reflection objects. These API-layer classes serve as serializable, language-agnostic representations that are converted into execution-specific plan-layer objects during agent plan construction.

api/src/main/java/org/apache/flink/agents/api/function · high confidence

The quickstart directory now includes a comprehensive set of end-to-end examples demonstrating Flink Agents capabilities. Users can explore parallel LLM fan-out patterns, ReAct agents with tool use (such as notifying a shipping manager), and agent skills (like a math calculator). The examples also cover multi-agent workflows, including a single-agent review analysis pipeline and a multi-stage workflow that aggregates review scores and generates improvement suggestions using the Flink Table API. Additionally, a new YAML-based agent declaration approach is introduced, allowing users to define agents, prompts, tools, and chat model connections via a YAML file and load them into the execution environment, providing an alternative to code-defined agents.

_python/flink\agents/examples/quickstart · high confidence

New Java EventListener interface for business event monitoring

A new EventListener interface has been added to the Java API, allowing users to register custom listeners that are notified synchronously when business events are received. This enables monitoring, metrics collection, and debugging by inspecting events before they are processed by actions, while explicitly excluding runtime observability trace records from this callback mechanism.

api/src/main/java/org/apache/flink/agents/api/listener · high confidence

New Java agent examples for review analysis, math skills, and model routing

Added several new Java example agents in the examples directory to demonstrate Flink Agents capabilities. The ReviewAnalysisAgent and TableReviewAnalysisAgent show how to analyze product reviews for satisfaction scores and reasons, with the latter specifically handling Flink Table API Row inputs. The ProductSuggestionAgent generates actionable improvement suggestions from aggregated review data. The MathAgent demonstrates using external skills (math-calculator) and tools (bash) for arithmetic. The ModelRoutingAgent illustrates routing requests through a MODEL\_ROUTER to select different chat models. All examples use Ollama as the chat model backend and include custom data types for serialization.

examples/src/main/java/org/apache/flink/agents/examples/agents · high confidence

New Java annotations for agent resources, actions, and cross-language support

The Java API now provides a set of annotations to declaratively define agent components and behavior. Developers can use @Action to mark methods as triggers for events or conditions, including cross-language targets via @PythonFunction. Resource management is simplified with annotations like @ChatModelSetup, @EmbeddingModelSetup, @Tool, @Prompt, @VectorStore, and @MCPServer, which allow the agent plan to automatically discover and manage these resources. Additionally, @ToolParam enables fine-grained control over tool arguments, including framework-injected parameters, and @Skills marks methods that provide agent skill definitions.

api/src/main/java/org/apache/flink/agents/api/annotation · high confidence

New Java examples for model routing, ReAct agents, skills, and YAML workflows

The examples directory now includes several new Java demonstrations: rule-based and LLM-as-judge model routing (ModelRoutingExample, ModelRoutingJudgeExample, and OpenAiModelRoutingExample for OpenAI), a ReAct agent for product review analysis (ReActAgentExample), a skills-based agent (SkillsAgentExample), single- and multi-agent streaming workflows (WorkflowSingleAgentExample, WorkflowMultipleAgentExample), and a YAML-declared agent workflow (YamlWorkflowAgentExample). Also in this area: 1 commit (0 fixes) modifying api, examples, plan.

examples/src/main/java/org/apache/flink/agents/examples, examples/src/main/java/org/apache/flink/agents/examples/openai · medium confidence

Users can now connect Flink Agents to OpenAI's Chat Completions API. This integration supports multimodal inputs (text, images, audio, and documents), native structured output for models like gpt-4o-mini and gpt-4o, and tool calling. It defaults to the gpt-4o-mini model and handles credential resolution via environment variables or explicit parameters.

_python/flink\_agents/integrations/chat\models/openai · high confidence

New RAG example agent with ChromaDB and Ollama integration

A new Retrieval-Augmented Generation (RAG) example has been added to the Python Flink Agents library. This example demonstrates how to build an agent that retrieves context from a ChromaDB vector store using Ollama embeddings and generates responses via an Ollama chat model. The package includes the agent definition, a utility to populate the knowledge base, a standalone execution script, and tests verifying that the agent's actions are correctly resolved and that the vector store uses cross-process persistence.

_python/flink\agents/examples/rag · high confidence

The tools directory now includes a comprehensive suite of scripts to streamline development and CI workflows. The new build.sh script automates the Java build and the packaging of Flink distribution JARs into the Python wheel structure, utilizing uv for Python dependency management. A new install.sh script provides an interactive, cross-platform installation wizard with a bundled UI helper (gum). Test execution is standardized via ut.sh (unit tests) and e2e.sh (end-to-end tests), which now support running against specific Flink versions and include cross-language resource consistency checks. Additionally, new validation tools ensure project hygiene: check-agents-md.py verifies that documentation version facts match source-of-truth files, check-license.sh runs Apache RAT license checks, and check-skill-schema.py ensures the coding-agent's bundled YAML schema remains in sync with the repository. The lint.sh script has been updated to use uv for Python linting and supports a check-only mode that no longer modifies files.

tools · high confidence

New built-in support for Azure OpenAI, OpenAI Responses API, and vLLM chat models

Users can now configure chat models for Azure OpenAI, the OpenAI Responses API, and vLLM servers directly within the integration. The new AzureOpenAIChatModelSetup allows specifying the Azure deployment name and the underlying model name for structured output and metrics. The OpenAIResponsesModelSetup enables the use of the newer Responses API with parameters like store and instructions. Additionally, VLLMChatModelConnection and VLLMChatModelSetup provide out-of-the-box support for vLLM servers, automatically applying defaults for the API base URL and key, and enabling native structured output for any model served by vLLM. Also in this area: 1 commit (0 fixes) modifying integrations/chat-models/openai; Native structured output is applied based on schema feasibility rather than model capability; Chat model integrations now return structured results with token usage and model attribution.

integrations/chat-models/openai/src/main · medium confidence · unverified

New common JSON Schema generator for chat model structured output

A new \PojoJsonSchemaGenerator\ utility has been added to the common chat-models integration module to standardize how Java POJOs are converted into JSON Schemas for native structured output. This generator ensures schemas are compatible with Python-side expectations by using the JSON Schema Draft 2020-12 dialect and aligning property ordering and required-field logic with Pydantic. It also correctly handles Jackson-specific annotations, such as serializing enum constants by their actual JSON values (via \@JsonProperty\ or \@JsonValue\) and respecting \@JsonIgnore\ fields, ensuring that the generated schemas accurately reflect the data contract for deserialization.

integrations/chat-models/common · high confidence

New observability event types for agent lifecycle, memory, and model interactions

The API now exposes a comprehensive set of typed event classes to track agent execution and internal state changes. This includes lifecycle tracking via AgentRunBeginEvent, chat interaction visibility through ChatRequestEvent and ChatResponseEvent, and context retrieval observability with ContextRetrievalRequestEvent and ContextRetrievalResponseEvent. Memory operations are now observable via ShortTermWriteEvent, ShortTermReadEvent, SensoryWriteEvent, SensoryReadEvent, LongTermGetEvent, LongTermSearchEvent, and LongTermUpdateEvent, all unified under the MemoryEvent base class. Additionally, model routing decisions are captured in ModelRoutingEvent, and tool interactions are tracked via ToolRequestEvent and ToolResponseEvent. These events enable users to monitor agent behavior, debug memory usage, and trace model selection logic. Also in this area: 3 commits (0 fixes) modifying api; 1 commit (0 fixes) modifying api, examples, plan; Refactored chat message model and separated model invocation results; Typed agent output views and strict built-in event validation; Agent execution controls, tool argument validation, and sub-agent rebuildability; and 1 more.

api/src/main/java/org/apache/flink/agents/api/event · medium confidence · unverified

New quickstart agent examples for review analysis, decision-making, and math skills

Added a new \python/flink\_agents/examples/quickstart/agents\ module containing five example agents: \ReviewAnalysisAgent\ and \TableReviewAnalysisAgent\ for analyzing product reviews (with the latter supporting Flink Table API Row inputs), \DecisionReviewAnalysisAgent\ for structured decision modeling (scoring, choice, and predicate questions), \ProductSuggestionAgent\ for generating improvement suggestions from review summaries, and \MathAgent\ which demonstrates using external skills and tools (like a bash calculator) via Ollama. These examples illustrate how to define prompts, configure chat models, handle input/output events, and integrate with Flink's runner context.

_python/flink\agents/examples/quickstart/agents · high confidence

New release tooling and multi-JDK support in release scripts

The release process in tools/releasing has been expanded with new scripts to automate branching (create\_release\_branch.sh, create\_snapshot\_branch.sh), version updates (update\_branch\_version.sh), and contributor listing (list\_contributors.sh). The binary release script (create\_binary\_release.sh) now builds and signs both binary JARs and Python sdists, while deploy\_staging\_jars.sh introduces a two-phase deployment that builds the API module with a JDK 11 classifier alongside the default JDK 17 build, enabling multi-JDK support for consumers.

tools/releasing · high confidence

New utility classes for cancellation detection, JSON validation, and tool result normalization

The plan module now includes three new utility classes to support agent execution and tool handling. CancellationUtils provides methods to detect thread interruptions and explicit task cancellations within exception cause chains without modifying thread state. JsonUtils offers a helper to verify object serializability via Jackson. ToolResultUtils handles the conversion of tool return values into text responses and normalizes sub-agent results to ensure they are JSON-compatible, rejecting payloads that cannot be serialized or re-bound after a failover.

plan/src/main/java/org/apache/flink/agents/plan/utils · high confidence

Python package now downloads required JARs from Maven Central during installation

The Python build process has been updated to automatically fetch and bundle necessary JAR dependencies from Maven Central when installing the package via pip. This change introduces a custom PEP 517 build backend that intercepts the wheel-building process to download JAR files listed in a manifest, verify their integrity using SHA-256 checksums, and include them in the final distribution. Users can now install the package without manually managing these external binary dependencies, and the download step can be skipped or redirected using environment variables if needed.

_python/\_build\backend · high confidence

Unified function schema and tool execution for Java and Python

The plan module now introduces FunctionSchema and FunctionTool to provide a unified, cross-language implementation for tool definitions. FunctionSchema compiles metadata and validates arguments using JSON Schema (Draft 2020-12) for Java methods, while FunctionTool acts as the plan-level wrapper that executes both Java static methods and Python functions via a resource adapter. This change aligns the Java and Python tool outcome contracts and unifies argument validation, allowing tools defined in either language to be handled consistently within the agent plan.

plan/src/main/java/org/apache/flink/agents/plan/tools · high confidence

YAML resource aliasing and cross-language support

The YAML loader now uses a centralized alias table to map short provider names (such as 'ollama', 'openai', 'anthropic', 'bedrock', 'vllm', 'watsonx', 'dashscope', 'azure\_openai', 'gemini', 'elasticsearch', 'opensearch', 's3\_vectors', 'milvus', 'chroma', 'mem0', and 'mcp') to their fully qualified implementation classes. This change introduces explicit support for cross-language resource declarations, allowing users to specify 'type: python' or 'type: java' in their YAML files to load the corresponding language-specific implementation for chat models, decision models, embedding models, vector stores, and MCP servers. The loader also now resolves function references for tools and actions using a standardized '\<module-or-class\>:\<qualname\>' format, enabling consistent tool injection across Java and Python environments.

api/src/main/java/org/apache/flink/agents/api/yaml · high confidence

Behavioural changes

A change to existing behaviour in flink-agents-integrations-observability-otel, integrations/observability/otel — 1 commit, 7 files: “\[integration\]\[observability\] Add OpenTelemetry GenAI exporter for Agent Traces (Phase 1) (\#1160)” (refs \#1160).

flink-agents-integrations-observability-otel, integrations/observability/otel · medium confidence · unverified

2 commits (1 fix) modifying integrations/embedding-models/openai

A change to existing behaviour in integrations/embedding-models/openai — 2 commits (1 fix), 2 files: “\[hotfix\]\[api\]\[java\] Move ResourceContext lookup factory to test utilities (\#1349)”; “\[integrations\]\[java\] Add OpenAI embedding model (\#1103)” (refs \#1349, \#1103).

integrations/embedding-models/openai · medium confidence · unverified

2 commits (1 fix) modifying integrations/vector-stores/milvus

A change to existing behaviour in integrations/vector-stores/milvus — 2 commits (1 fix), 2 files: “\[Feature\]\[Integration\]\[Java\] Add Milvus vector store integration (\#663)”; “\[hotfix\]\[api\]\[java\] Move ResourceContext lookup factory to test utilities (\#1349)” (refs \#663, \#1349).

integrations/vector-stores/milvus · medium confidence · unverified

2 commits (1 fix) modifying integrations/vector-stores/pgvector

A change to existing behaviour in integrations/vector-stores/pgvector — 2 commits (1 fix), 2 files: “\[hotfix\]\[api\]\[java\] Move ResourceContext lookup factory to test utilities (\#1349)”; “\[integrations\]\[java\] Add PostgreSQL pgvector vector store (\#1143)” (refs \#1349, \#1143).

integrations/vector-stores/pgvector · medium confidence · unverified

Added bundled dependency notices and license files

The distribution package now includes a comprehensive NOTICE file and individual license texts for all bundled third-party dependencies. This ensures compliance with open-source licensing requirements by explicitly listing dependencies such as Jackson, Netty, AWS SDK, and Anthropic Java client, along with their respective licenses (Apache 2.0, MIT, BSD, EPL2, etc.), and providing the full license text for each in the \META-INF/licenses\ directory.

dist · high confidence

Introduce secure, digest-pinned URL skill sources in Java API

The Java API for agent skills now includes a new \Skills\ configuration resource and \SkillSourceSpec\ model to define where skills are loaded from. A key behavioral change is the introduction of strict security requirements for URL-based skill sources: the new \SkillUrlUtils\ enforces HTTPS by default and adds support for SHA-256 digest pinning to verify the integrity of downloaded skill archives. Users can now explicitly allow insecure HTTP via \fromUrlUnsafe\ or use \fromUrlWithSha256\ to require a specific digest, ensuring that remote skill sources are both encrypted and tamper-proof.

api/src/main/java/org/apache/flink/agents/api/skills · high confidence

Java chat model API refactored into separate connection and setup abstractions with structured output support

The Java chat model API has been restructured to separate connection management from request setup. A new BaseChatModelConnection class handles provider-specific connection details and native structured-output capabilities, while BaseChatModelSetup manages prompt application, tool binding, and request preparation. The API now supports explicit output schemas via a new StructuredOutputStrategy enum (AUTO, NATIVE, PROMPT) that controls whether native structured output is used or falls back to prompt engineering. Token usage metrics are now recorded through the setup layer with model-scoped metric groups.

api/src/main/java/org/apache/flink/agents/api/chat/model · high confidence

Move MCP integration to dedicated module

The Model Context Protocol (MCP) integration has been relocated from the API package to a new \python/flink\_agents/integrations/mcp\ module. This change introduces the \MCPServer\, \MCPTool\, and \MCPPrompt\ classes, along with utility functions for handling MCP content types, within the integrations namespace to better organize external protocol support.

_python/flink\agents/integrations/mcp · high confidence

Ollama integration now supports explicit model specification and reasoning parameters

The Ollama chat model setup now requires an explicit model name during initialization and exposes configuration for reasoning-related behaviors. Users can now specify the target Ollama model (e.g., 'qwen3:4b') directly in the setup descriptor, and control whether the model should engage in 'think' mode and whether reasoning content should be extracted via the 'think' and 'extract\_reasoning' parameters, aligning the Java integration's behavior with the Python version.

integrations/chat-models/ollama/src/main · high confidence

The Python package has been restructured to include a build backend and a manifest file (jar\_manifest.json) that specifies Apache Flink JAR artifacts (versions 1.20 through 2.3) to be downloaded from Maven Central during pip install. This change shifts the distribution model from bundling JARs directly to fetching them at install time, ensuring the package includes the necessary Flink runtime libraries for agent execution.

python · high confidence

Fixes

1 commit (1 fix) fixing tools/ci

A fix in tools/ci — 1 commit (1 fix), 1 file: “\[hotfix\]\[ci\] Finalize PyArrow 11 on exit in Flink 1.20 tests (\#1343)” (refs \#1343).

tools/ci · medium confidence · unverified

Test coverage

Add end-to-end tests for MCP server integration with and without prompts; Added Java test coverage for agent plan configuration, cross-language execution, and resource declarations; Added Java unit tests for Flink Agents API components; Added Java-side end-to-end tests for cross-language agent resources; Added Python API tests for Flink Agents; Added Python runtime test suite for agents, sub-agents, and cross-language bridges; Added Python test fixtures for cross-language skill installation and resource lifetime; Added Python tests for Java/Python agent plan and config compatibility; Added comprehensive test coverage for the Flink Agents runtime operator; Added e2e test resources for Python Flink Agents; Added end-to-end tests for YAML-declared agents and tool parameter injection; Added integration tests for DashScope, Ollama, and text-only chat model providers; Added integration tests for Elasticsearch vector store; Added integration tests for the Chroma vector store implementation; Added integration tests for the local Ollama embedding model; Added test coverage for Flink Agents runtime components; Added test coverage for Java agent skill runtime components; Added test infrastructure for tool schema conversion; Added test resources for CEL condition evaluation and agent skill definitions; Added test resources for agent skills; Added tests for Amazon Bedrock chat model integration; Added tests for Anthropic chat model integration; Added tests for DashScope and OpenAI embedding model integrations; Added tests for MCP integration server and tool serialization; Added tests for OpenAI and Azure OpenAI chat model integrations; Added tests for Python environment management and remote execution configuration; Added tests for Python function schema extraction and tool execution; Added tests for Python-Java runtime bridge utilities; Added tests for RAG agent module importability and vector store persistence; Added tests for Watsonx.ai chat model integration; Added tests for durable execution, async execution, and Python bridge contracts; Added tests for feedback runtime components; Added tests for internal sub-agent runtime behavior; Added tests for plan actions; Added tests for quickstart example agents and workflows; Added tests for runtime condition evaluation and action matching; Added tests for runtime metrics and trace logging components; Added tests for task lifecycle listener notifications; Added tests for the Anthropic chat model integration; Added tests for the Azure OpenAI chat model integration; Added tests for the Python YAML agent loader and alias resolution; Added tests for the async execution runtime; Added tests for the parallel execution engine's coordination, locking, and Python resource handling; Added unit and integration tests for the agents runtime memory subsystem; Added unit tests for ActionState runtime components; Added unit tests for MCP integration components; Added unit tests for Ollama chat model integration; Added unit tests for the Flink Agents installation and recovery tooling; Expanded end-to-end test coverage for Flink Agents integration and runtime behavior; Initial test coverage for the Python Flink Agents plan module; Integration test suite for Flink Agents installer; Introduce YAML API for declaring agents; New cross-language e2e tests for Flink Agents resources; New e2e test scripts for agent plan compatibility, resource consistency, and checkpoint recovery; New end-to-end integration tests for Flink Agents; New end-to-end tests for cross-language agent resources; New integration tests for agent skills, async execution, and multi-provider models; Structured tool-invocation assertions for end-to-end tests.

Dependencies

The distribution module now builds and ships Flink Agents packages for Apache Flink versions 1.20, 2.0, 2.1, 2.2, and 2.3. This is achieved through a new Maven multi-module structure that includes a shared 'common' module for dependencies and specific modules for each Flink version, allowing users to select the distribution artifact that matches their cluster's Flink release.

(dependencies) · high confidence

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 53 → 59 (+5.8)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 58 → 58 (-0.1)
  • Architecture 68 → 69 (+0.8)
  • Maturity 48 → 78 (+29.8)
  • Readiness 52 → 54 (+2.1)
  • Security 74 → 66 (-7.8)
  • Performance 71 → 85 (+13.7)

Resolved (74)

  • BaseChatModelSetup.chat (cognitive 21) (python/flink_agents/api/chat_models/chat_model.py)
  • DecisionModelAction.processDecisionRequest (cognitive 16) (plan/src/main/java/org/apache/flink/agents/plan/actions/DecisionModelAction.java)
  • Duplicated block (10 lines × 2) (integrations/chat-models/gemini/src/main/java/org/apache/flink/agents/integrations/chatmodels/gemini/GeminiChatUtils.java)
  • Duplicated block (12–13 lines × 3) (runtime/src/main/java/org/apache/flink/agents/runtime/operator/ActionExecutionOperator.java)
  • Duplicated block (14–15 lines × 2) (examples/src/main/java/org/apache/flink/agents/examples/WorkflowSingleAgentExample.java)
  • Duplicated block (17 lines × 3) (examples/src/main/java/org/apache/flink/agents/examples/ModelRoutingExample.java)
  • Duplicated block (5 lines × 2) (integrations/chat-models/ollama/src/main/java/org/apache/flink/agents/integrations/chatmodels/ollama/OllamaChatModelConnection.java)
  • Duplicated block (7 lines × 2) (python/flink_agents/api/events/chat_event.py)
  • Duplicated block (7 lines × 2) (runtime/src/main/java/org/apache/flink/agents/runtime/subagent/DeferredSubagentFuture.java)
  • Duplicated block (8 lines × 2) (plan/src/main/java/org/apache/flink/agents/plan/actions/ToolCallAction.java)
  • LlmJudgeRoutingExecutor.selectWithinBudget (cognitive 17) (plan/src/main/java/org/apache/flink/agents/plan/routing/LlmJudgeRoutingExecutor.java)
  • Members sharing a duplicated core (4 members, 50+ identical tokens) (integrations/chat-models/anthropic/src/main/java/org/apache/flink/agents/integrations/chatmodels/anthropic/AnthropicChatUtils.java)
  • No assertions: agentRunBeginEventJavaSnapshotIsStable (api/src/test/java/org/apache/flink/agents/api/CrossLanguageEventSnapshotTest.java)
  • No assertions: anInternalHandleSeparatedByADeferredOneIsRefused (runtime/src/test/java/org/apache/flink/agents/runtime/subagent/SubagentFutureGroupMixedBatchTest.java)
  • No assertions: buildSkillsSupportsAllUrlSourceSecurityOptions (api/src/test/java/org/apache/flink/agents/api/yaml/YamlLoaderBuildersTest.java)
  • No assertions: chatRequestEventJavaSnapshotIsStable (api/src/test/java/org/apache/flink/agents/api/CrossLanguageEventSnapshotTest.java)
  • No assertions: chatResponseEventJavaSnapshotIsStable (api/src/test/java/org/apache/flink/agents/api/CrossLanguageEventSnapshotTest.java)
  • No assertions: classifiesBareEventTypes (plan/src/test/java/org/apache/flink/agents/plan/condition/TriggerConditionTest.java)
  • No assertions: classifiesNonEventTypesAsExpressions (plan/src/test/java/org/apache/flink/agents/plan/condition/TriggerConditionTest.java)
  • No assertions: classifiesReservedExpressionCandidates (plan/src/test/java/org/apache/flink/agents/plan/condition/TriggerConditionTest.java)
  • …and 54 more

New (51)

  • AgentPlan.validateDecisionModel (cognitive 17) (plan/src/main/java/org/apache/flink/agents/plan/AgentPlan.java)
  • AgentPlan.validateDecisionModel (cyclomatic 16) (plan/src/main/java/org/apache/flink/agents/plan/AgentPlan.java)
  • AgentPlan.validateRoutingStrategies (cognitive 18) (plan/src/main/java/org/apache/flink/agents/plan/AgentPlan.java)
  • AgentPlan.validateRoutingStrategies (cyclomatic 16) (plan/src/main/java/org/apache/flink/agents/plan/AgentPlan.java)
  • AgentTraceSpans.buildExecutionSpan (cognitive 44) (integrations/observability/otel/src/main/java/org/apache/flink/agents/integrations/observability/otel/AgentTraceSpans.java)
  • AgentTraceSpans.buildExecutionSpan (cyclomatic 27) (integrations/observability/otel/src/main/java/org/apache/flink/agents/integrations/observability/otel/AgentTraceSpans.java)
  • ClassTooLong: PgVectorVectorStore (integrations/vector-stores/pgvector/src/main/java/org/apache/flink/agents/integrations/vectorstores/pgvector/PgVectorVectorStore.java)
  • DecisionModelInvoker.decideWithRetries (cognitive 18) (plan/src/main/java/org/apache/flink/agents/plan/actions/DecisionModelInvoker.java)
  • DecisionModelRoutingExecutor.renderInput (cognitive 33) (plan/src/main/java/org/apache/flink/agents/plan/routing/DecisionModelRoutingExecutor.java)
  • DecisionModelRoutingExecutor.renderInput (cyclomatic 19) (plan/src/main/java/org/apache/flink/agents/plan/routing/DecisionModelRoutingExecutor.java)
  • Duplicated block (12 lines × 2) (python/flink_agents/api/events/chat_event.py)
  • Duplicated block (13–14 lines × 3) (runtime/src/main/java/org/apache/flink/agents/runtime/operator/ActionExecutionOperator.java)
  • Duplicated block (16–17 lines × 2) (examples/src/main/java/org/apache/flink/agents/examples/WorkflowSingleAgentExample.java)
  • Duplicated block (17–18 lines × 3) (examples/src/main/java/org/apache/flink/agents/examples/ModelRoutingExample.java)
  • Duplicated block (27–28 lines × 2) (examples/src/main/java/org/apache/flink/agents/examples/openai/OpenAiDecisionRoutingExample.java)
  • Duplicated block (7 lines × 2) (examples/src/main/java/org/apache/flink/agents/examples/openai/OpenAiDecisionRoutingExample.java)
  • Duplicated block (8 lines × 2) (integrations/vector-stores/milvus/src/main/java/org/apache/flink/agents/integrations/vectorstores/milvus/MilvusVectorStore.java)
  • Duplicated block (8 lines × 2) (plan/src/main/java/org/apache/flink/agents/plan/routing/DecisionModelRoutingExecutor.java)
  • Duplicated block (8 lines × 2) (python/flink_agents/api/events/chat_event.py)
  • FileTooLong: pgvector/PgVectorVectorStore.java (integrations/vector-stores/pgvector/src/main/java/org/apache/flink/agents/integrations/vectorstores/pgvector/PgVectorVectorStore.java)
  • …and 31 more

Changes since last survey

  • 32 commits — 22 feature/other, 10 fixes

By area

  • runtime/src — 10 commits
  • integrations/chat-models — 5 commits
  • python/flink_agents — 5 commits
  • .github/workflows — 4 commits
  • (root) — 1 commit
  • dist/src — 1 commit
  • docs/config.toml — 1 commit
  • docs/content — 1 commit
  • examples/src — 1 commit
  • integrations/observability — 1 commit
  • plan/src — 1 commit
  • python/NOTICE — 1 commit

Notable commits

  • fix: [hotfix][api][java] Move ResourceContext lookup factory to test utilities (#1349)
  • fix: [hotfix][ci] Cancel superseded CI runs for the same PR (#1359)
  • fix: [hotfix][ci] Finalize PyArrow 11 on exit in Flink 1.20 tests (#1343)
  • fix: [hotfix][ci] Reduce test logs and update Java IT and ReAct tests (#1323)
  • fix: [hotfix][docs] Apply review guidance during development (#1358)
  • fix: [hotfix][docs] Centralize stable release versions in setup examples (#1321)
  • fix: [hotfix][docs] Finalize Flink Agents 0.4.0 release defaults (#1339)
  • fix: [hotfix][python] Include NOTICE in Python distributions
  • fix: [hotfix][runtime] Initialize output identity in routing recovery tests (#1371)
  • fix: [runtime] Fix action-state key collisions between event occurrences with identical attributes (#1342)
  • change: Update docs config for release-0.4
  • change: Update version to 1.0-SNAPSHOT
  • change: [api][java][python] Propagate user context from request events to responses (#1352)
  • change: [api][plan][java] Add a decision-model routing strategy for MODEL_ROUTER (#1330)
  • change: [docs] Standardize Alibaba Cloud Model Studio naming (#1329)
  • change: [integration][java] Send user images and documents through the OpenAI Responses API (#1275)
  • change: [integration][java] Send user images, audio, video and documents to Gemini (#1326)
  • change: [integration][observability] Add OpenTelemetry GenAI exporter for Agent Traces (Phase 1) (#1160)
  • change: [integrations][java] Add PostgreSQL pgvector vector store (#1143)
  • change: [integrations][java][docs] Send images and documents in tool results through the OpenAI Responses API (#1364)
  • …and 12 more

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed

Added bounded contexts (1)

  • flink-agents-integrations-observability-otel

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

apache/flink-agents 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 9 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 7a8095052ead49082327d96017294339ca783e24 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — 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.3+preprod-b921b700395b.