alfin06/swegent-issues-filtered huggingface dataset:
Enable v1 support for WebSurfer Agent in AGS


Explore early tests on how to support websurfer agents in AGS. 

- enable adding [WebSurfer](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer) agent to any team 
- enable viewing websurfer text messages in the ags ui 
- enable viewing websurfer multimodal messages in ui. 

Labels: proj-studio
State: closed
Duplicate Models Prevent Model Settings Overrides from Working

### Issue

When models with a duplicate names exist in aider's model-settings.yml, custom model settings defined in `~/.aider.model.settings.yml` fail to override the duplicated models configuration.

Duplicate model names found:
* `azure/o4-mini`
* `openai/o4-mini`
* `openrouter/openai/o4-mini`
* `vertex_ai/claude-3-7-sonnet@20250219`
* `vertex_ai/claude-opus-4@20250514`
* `vertex_ai/claude-sonnet-4@20250514`

### Reproduction
1. Choose a model with duplicate entries in `model-settings.yml`.
2. Add custom settings for that model in `~/.aider.model.settings.yml`
3. Attempt to use the model with custom settings
4. Observe that default settings are used instead of custom overrides

**Example:**
Consider trying to override settings for `openai/o4-mini` in `~/.aider.model.settings.yml`:
                                                                                           
```yaml
- name: openai/o4-mini
  edit_format: whole  # changed
  weak_model_name: openai/gpt-4.1-mini
  use_repo_map: false  # changed
  examples_as_sys_msg: true
  use_temperature: false
  editor_model_name: openai/gpt-4.1
  editor_edit_format: editor-diff
  system_prompt_prefix: 'Formatting re-enabled. '
  accepts_settings:
  - reasoning_effort
```

**Expected behavior:** The custom settings should be applied to `openai/o4-mini` when selected. Aider should use the "whole" edit format and shouldn't use repo map.

**Actual behavior:** The custom settings are ignored, and the model uses default settings instead. Edit format is still `diff`, and the repo map is used.
                                                              
### Root cause
If model with the same name appears multiple times in the model-settings.yml, the override mechanism removes the first model instance, adds a new instance to the end of model registry, but the actual one which is used would the second one from `model-settings.yml`.

### Impact
- Users cannot customize model behavior through configuration files
- Inconsistent behavior between expected and actual model settings

### Version and model info

Aider v0.85.1
Main model: openai/o4-mini with diff edit format
Weak model: openai/gpt-4.1-mini
Git repo: .git with 54 files
Repo-map: using 4096 tokens, auto refresh

State: closed
Bedrock Sonnet v2 and Vertex Gemini 2.0 flash: Cannot read properties of undefined (reading 'toolCalls')

### Description

When i try to use `anthropic.claude-3-5-sonnet-20241022-v2:0` on amazon-bedrock, and `gemini-2.0-flash-exp` on Vertex im getting this error: 
[500] Cannot read properties of undefined (reading 'toolCalls')

### Code example

```ts
  const response = await streamText({
    model,
    system: 'You are a helpful assistant. You always try to help the user with their questions.',
    messages: messages as CoreMessage[],
    onFinish: (result) => {
      console.log(result)
    },
  })
```

### AI provider

  "ai": "4.0.27",  "@ai-sdk/amazon-bedrock": "1.0.6",     "@ai-sdk/anthropic": "1.0.6",     "@ai-sdk/google": "1.0.12",     "@ai-sdk/google-vertex": "2.0.13",     "@ai-sdk/openai": "1.0.13",     "@ai-sdk/vue": "1.0.7", 

### Additional context

_No response_

Labels: bug
State: closed
.NET Use tool call for next speaker selection

### What feature would you like to be added?

Use the following tool call to select next speaker
```
pubic async Task<string> SelectNextSpeaker(string name, string reason)
```

### Why is this needed?

The LLM-based select next speaker prompt doesn't work well in when conversation language is Chinese, according to the feedback from @JeffreySu 

Provide an option to use tool call might be helpful in mitigating such scenario

Labels: dotnet, 0.2, needs-triage
State: closed
Add support for combinations of termination conditions in AGS

Currently, you can only specify one termination condition in AGS. 
```python
"termination_condition": {
    "component_type": "termination",
    "termination_type": "MaxMessageTermination",
    "max_messages": 10
  }
```
However, AgentChat supports combinations of [termination conditions](https://github.com/microsoft/autogen/blob/main/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py) 

```python

termination = termination = MaxMessageTermination(3) | TextMentionTermination("stop")
``` 

## What 

Extend AGS component factory and spec to support combinations of termination conditions

```json
 "termination_condition": {
    "component_type": "termination",
    "termination_type": "CombinationTermination",
    "operator": "or",
    "conditions": [
      {
        "component_type": "termination",
        "termination_type": "TextMentionTermination",
        "text": "TERMINATE"
      },
      {
        "component_type": "termination",
        "termination_type": "MaxMessageTermination",
        "max_messages": 1
      }
    ]
  }
```

Labels: proj-studio
State: closed
What is the current way to export an thread and preload a chat with a team in v0.4

I'm fairly new to the AutoGen project and we're exploring it for our use case, but as I was prototyping it in a notebook I was wondering what is the way for us to be able to export a chat and preload it in a team. For example:

```python
team = SelectorGroupChat(
    participants=[customer_service_agent, manager_agent, finance_agent],
    allow_repeated_speaker=False,
    model_client=OpenAIChatCompletionClient(model="gpt-4o"),
)
```

I can do this to get the conversation history

```python
conversation = await team.run(task="Hello I would like a refund!")
print(conversation.messages)
```

But I would love to be able to export it as JSON

```python
import json

conversation = await team.run(task="Hello I would like a refund!")
print(json.dumps(conversation.messages))
```

And equally I would love to be able to import the conversation history JSON so anything ran against in `team.run()`

```python
conversation_history = json.loads(conversation_history_json)
conversation = await team.run(conversation=conversation_history, task="Hi world!")
```

Also, is it possible to message the agents with nothing (ideally as a specific flag)? We would love to be able to have agents give a meaningful intro message, but this isn't critical - we can build workarounds for this.

Note that this is for the v0.4 release!

Labels: proj-agentchat, awaiting-op-response
State: closed
Azure AI Model Inference API , requires custom url params to be set for the openai compatibility API

### Feature Description

Azure AI Model Inference API , requires custom url params to be set for the openai compatibility API

### Use Cases

As mentioned [here](https://learn.microsoft.com/en-us/azure/machine-learning/reference-model-inference-chat-completions?view=azureml-api-2) Azure AI Model Inference API which is a openai compatible service , requires custom url param `api-version` to be set. 

### Additional context

_No response_

Labels: feature, ai/provider
State: closed
Implement remove_subscription in worker runtime

Worker runtime currently does not support subscription removal. This feature is needed for the updated direct messaging method used for multi-process workflows. Specifically, agents sending RPC messages to other agents will need to unsubscribe from the response channel once a response has been received

Labels: x-lang
State: closed
OpenAI Embeddings do not work due to a connection error

### Bug Description

Run the Vector RAG Template and observe that there is a connection error when using OpenAI embeddings.

### Reproduction

1. Create a sample RAG vector template
2. Run
3. Observe connection error

### Expected behavior

This flow should execute successfully, particularly as it is a built in template.

### Who can help?

_No response_

### Operating System

macOS 15.1

### Langflow Version

1.0.19

### Python Version

None

### Screenshot

_No response_

### Flow File

_No response_

Labels: bug
State: closed
message conversion bug

> I'm releasing `4.0.30` with a fix. The error masks another error that will be available in fullStream or if you enable error message forwarding / log it: https://sdk.vercel.ai/docs/ai-sdk-ui/chatbot#error-messages> 
> > 
> Thanks! For me the issue was `Full stream error: [Error [AI_APICallError]: * GenerateContentRequest.contents[2].parts: contents.parts must not be empty.` similar to #3775. The first message worked fine, but when I sent a second message I saw the error because of empty tool messages from https://github.com/vercel/ai-chatbot/blob/c5a57fd7a84535db2e1262fc059a06f73cc85689/lib/utils.ts#L99> 
> > 
> ```ts> 
> messages  [> 
>   { role: 'user', content: 'test', toolInvocations: [] },> 
>   {> 
>     role: 'assistant',> 
>     content: "Understood. I'm ready to help with your questions.\n",> 
>     toolInvocations: []> 
>   },> 
>   { role: 'user', content: 'test' }> 
> ]> 
> coreMessages [> 
>   { role: 'user', content: 'test' },> 
>   { role: 'assistant', content: [ [Object] ] },> 
>   { role: 'tool', content: [] },> 
>   { role: 'user', content: 'test' }> 
> ]> 
> ```> 
> > 
> Gemini contents:> 
> > 
> ```ts> 
> "contents": [> 
>       {> 
>         "role": "user",> 
>         "parts": [> 
>           {> 
>             "text": "test"> 
>           }> 
>         ]> 
>       },> 
>       {> 
>         "role": "model",> 
>         "parts": [> 
>           {> 
>             "text": "Understood. I'm ready to help with your questions.\n"> 
>           }> 
>         ]> 
>       },> 
>       {> 
>         "role": "user",> 
>         "parts": []    <----- causing the error> 
>       },> 
>       {> 
>         "role": "user",> 
>         "parts": [> 
>           {> 
>             "text": "test"> 
>           }> 
>         ]> 
>       }> 
>     ],> 
> ``` 

 _Originally posted by @trevorpfiz in [#4301](https://github.com/vercel/ai/issues/4301#issuecomment-2578626408)_

Labels: bug, ai/core
State: closed
Capitalization inconsistency between docs & type on `openaiChatResponseSchema`

### Description

The logProbs param here should be `logProbs` in the schema, not `logprobs` according to the docs:
https://sdk.vercel.ai/providers/ai-sdk-providers/azure

<img width="761" alt="Image" src="https://github.com/user-attachments/assets/df6871bb-a6c5-4d99-9a1f-8e6eeb0456bb" />

See `openaiChatResponseSchema`.

<img width="487" alt="Image" src="https://github.com/user-attachments/assets/a2f8d885-c3cb-460f-96a8-7013b5cc0f33" />

### Code example

_No response_

### AI provider

"@ai-sdk/azure": "^1.1.0",

### Additional context

_No response_

Labels: bug, documentation
State: closed
Re-Asks with Repair Tool Call

### Feature Description

Support "re-asks" with experimental repair tool call. An implementation of re-ask would be to return a tool call result, but with the error (no tool exists, args doesn't match input schema) message attached. https://x.com/lgrammel/status/1865067908214255978

Based on the current implementation, it doesn't seem like it's possible to return a generic object (like in a tool call result), only an actual tool call object: https://github.com/vercel/ai/blob/main/packages/ai/core/generate-text/parse-tool-call.ts


### Use Cases

Instead of throwing an error, generateText or streamText would "consume" a maxStep and try again with the message attached.

### Additional context

It might be worth deferring input schema validation until the execute method. This is to let parallel tool calls that don't have an error proceed.

Right now for [`generateText`](https://github.com/vercel/ai/blob/e7a9ec9e916b7cc49e3296d7644be62f9949263c/packages/ai/core/generate-text/generate-text.ts#L385-L408), it's written as

```
toolCalls = toolCalls.map(parseToolCalls)
toolResults = toolCalls.map(executeToolCalls)
```

but maybe it should be

```
toolResults = toolCalls.map(executeToolCalls(parseToolCalls))
```

Instead of throwing an error in `doParseToolCall`, we can set a boolean like `mismatchedArgs`. If the toolName doesn't exist, we could define a wild card fall back tool that developers could provide custom execute method for.

https://github.com/vercel/ai/blob/main/packages/ai/core/generate-text/parse-tool-call.ts

Labels: feature, ai/core
State: closed
Access `reasoning_content` from DeepSeek API

### Feature Description

The new `deepseek-reasoner` model streams reasoning process in `chunk.choices[0].delta.reasoning_content`, but right now, it seems there's no way to access it through the AI SDK.

https://api-docs.deepseek.com/guides/reasoning_model

Labels: feature, ai/provider
State: closed
Output entries can be replayed to service endpoints

It seems that it is possible to get in a state where we accept an output journal entry, but don't complete the invocation, if there is a crash at the exact time between the invocation journal entry and invocation end events are processed
The lack of atomicity is fine if, upon retry, we observe that the journal already has everything we need, so instead of replaying to service endpoint we simply skip straight to invocation completion



State: closed
Team to support a list of messages as input to a task

Currently a team only support a single message for task.

```python
result = await team.run(task="...")
```

It should support a list of messages, to prepopulate the context of the agents.

```python
result = await team.run(task=[TextMessage(...), TextMessage(...)])
```

This allows passing a previous conversation history from another team. 

This is also useful for nested chats to prepopulate the team participants with messages before generating a response. 

Labels: proj-agentchat
State: closed
Add reasoning token support to useChat

### Feature Description

Following PR #4462 which added reasoning token support, it would be great to extend this functionality to the `useChat` hook as well.

### Use Cases

When building chatbots with `useChat`, we want to display the reasoning process to users


Labels: feature, ai/ui
State: closed
Update AssistantAgent tool call behavior

- limit to 1 tool call iteration only by default
- default behavior is to return tool call result directly, add optional parameter to allow the final string-only response with no tool calls.
- disable parallel tool call when handoff is present
- support method to modify the tools the agent has access to 

Related: #4483 #4307 

Labels: proj-agentchat
State: closed
`CoreMessage` and `UIMessage` miss `type` field

### Description

following [this](https://sdk.vercel.ai/docs/foundations/prompts#example-assistant-message-with-tool-call) and seems like `CoreMesssage` or `UIMessage` miss the `type` field. Or does the latest version not align with the docs? Can someone clear the air?

### Code example

```ts
const { text, toolResults, toolCalls } = await generateText({
  model,
  messages: [
    { role: 'user', content: 'hello' },
    {
      role: 'assistant',
      content: 'Hello',
    },
    { role: 'user', content: 'show me my account please' },
    {
      type: 'tool-call', // ⛔️ Object literal may only specify known properties, and 'type' does not exist in type 'UIMessage'
      toolCallId: 'call_f7bsXvQFhv8tjEZdUjHah42v',
      toolName: 'showMyAccount',
      args: {},
    },
    { role: 'user', content: 'thanks g' },
  ],
});
```

EDIT:

found `CoreToolMessage` and it looks like:
```ts
type CoreToolMessage = {
    role: 'tool';
    content: ToolContent;
    /**
  Additional provider-specific metadata. They are passed through
  to the provider from the AI SDK and enable provider-specific
  functionality that can be fully encapsulated in the provider.
   */
    experimental_providerMetadata?: ProviderMetadata;
};
```

Please update the docs.

### AI provider

@ai-sdk/openai ^1.1.2

### Additional context

_No response_

Labels: bug, documentation
State: closed
Add Magentic-One Orchestrator to AutoGen Studio

need to add the orchestrator from magentic-one in agentchat as orchestrator in AGS



Labels: proj-studio
State: closed
Feature Request: Add Alibaba Cloud Qwen Model Support.

### Feature Description

## Qwen2.5 Passed Deekseek

> I am also a developer, I could have done that however, I am also unaware of the code structure of the project and have to focus on upcoming 12 exams other if this in pending after 03 March, 2025. I am happy to assigned this project.

### Use Cases

None, like other models.

### Additional context

None.

Labels: feature
State: closed
convertToCoreMessages now returns message content after tools, breaking subsequent LLM calls

### Description

[4.1.12 introduced a change in behavior in convertToCoreMessages](https://github.com/vercel/ai/pull/4591):

Specifically, when given assistant messages that have content and tool invocations, convertToCoreMessages now puts the tools before the content, when it used to put the tools after the content.

Unfortunately, this distinction matters for certain LLM vendors like Anthropic. Once the tool result is given for resubmission, we see messages like:

> An error occurred: The model returned the following errors: Your API request included an `assistant` message in the final position, which would pre-fill the `assistant` response. When using tools, pre-filling the `assistant` response is not supported.

### Code example

So this input:

```typescript
  const coreMessages = convertToCoreMessages([
    {
      role: "user",
      content: "request",
    },
    {
      role: "assistant",
      content: "response",
      toolInvocations: [
        {
          state: "result",
          step: 0,
          toolCallId: "tooluse_5oQ2pIcgQlOhVeq8dDlmhw",
          toolName: "toolName",
          args: {
            foo: "bar",
          },
          result: {
            other: "stuff",
          },
        },
      ],
    },
  ]);
```

Used to return:

```typescript
[
    {
        "role": "user",
        "content": "input asking for a tool"
    },
    {
        "role": "assistant",
        "content": "response"
    },
    {
        "role": "assistant",
        "content": [
            {
                "type": "tool-call",
                "toolCallId": "tooluse_5oQ2pIcgQlOhVeq8dDlmhw",
                "toolName": "toolName",
                "args": {
                    "foo": "bar"
                }
            }
        ]
    },
    {
        "role": "tool",
        "content": [
            {
                "type": "tool-result",
                "toolCallId": "tooluse_5oQ2pIcgQlOhVeq8dDlmhw",
                "toolName": "toolName",
                "result": {
                    "other": "stuff"
                }
            }
        ]
    }
]
```

And now content comes after the tool calls:

```typescript
[
    {
        "role": "user",
        "content": "input asking for a tool"
    },
    {
        "role": "assistant",
        "content": [
            {
                "type": "tool-call",
                "toolCallId": "tooluse_5oQ2pIcgQlOhVeq8dDlmhw",
                "toolName": "toolName",
                "args": {
                    "foo": "bar"
                }
            }
        ]
    },
    {
        "role": "tool",
        "content": [
            {
                "type": "tool-result",
                "toolCallId": "tooluse_5oQ2pIcgQlOhVeq8dDlmhw",
                "toolName": "toolName",
                "result": {
                    "other": "stuff"
                }
            }
        ]
    },
    {
        "role": "assistant",
        "content": "response"
    }
]
```

### AI provider

@ai-sdk/anthropic 1.1.5

### Additional context

_No response_

Labels: bug
State: closed
Compatibility Issue: Tool-Calling Agent and Components with Build Tools and Predefined Argument Schemas

### Bug Description

When using components with predefined build tools and argument schemas as tools (e.g., SERP API or Retriever), errors are encountered. The components fail to integrate seamlessly with tool-calling agents.


When using components with predefined build tools and argument schemas as tools (e.g., SERP API or Retriever), errors are encountered. The components fail to integrate seamlessly with tool-calling agents.

Tell Us What You See!

Error Messages:

	1.	SERP API Tool:

ToolException: Error in SerpAPI search: cannot access local variable 'wrapper' where it is not associated with a value


	2.	Retriever as a Tool:

‘RetrieverToolComponent’ object has no attribute ‘set_event_manager’





### Reproduction

Steps to Reproduce the Behavior:

	1.	Attempt to use a component like SERP API or Retriever as a tool.
	2.	Call the agent using these components.
	3.	Observe the error output.

### Expected behavior

The components should integrate and function normally with the tool-calling agent, creating the desired tools without errors.
 ### Possible Edits

To resolve this issue:
	•	Aggregate the component-as-tools functionality and ensure that build_tools logic aligns with the logic used for components as tools.
	•	Ensure consistent compatibility between tool-calling agents and components with predefined schemas.


### Who can help?

_No response_

### Operating System

Mac OS

### Langflow Version

1.1

### Python Version

3.12

### Screenshot

_No response_

### Flow File

_No response_

Labels: bug
State: closed
Autogen core quickstart guide fails about half the time

[This guide](https://microsoft.github.io/autogen/dev/user-guide/core-user-guide/quickstart.html) will fail something like half the time. 

The problem is that a python package is missing, and when the LLM instructs autogen to install the package, it doesn't include the code its supposed to run along with the install command. This causes the package to be installed, but no code to actually be executed.

The same thing can happen if there are multiple rounds of this interaction, where any round that doesn't include the actual python code will cause the task to fail

Labels: code-execution
State: closed
Chat History Reduction

### What feature would you like to be added?

I would like the ability for agents to only read chat history from select other agents or the last n messages.

Certain agents might only need the history from other select agents (in more of a process flow)

Certain agents might only need access to the last N messages. 

### Why is this needed?

Currently, long running group chats can consume a significant number of tokens.

State: closed