- Add max_context field to CondensationConfig
- Support 'internal' keyword for local HuggingFace model in condensation
- Add internal model initialization with temperature=0.3, top_p=0.8, repeat_penalty=1.1
- Create condensation system prompts (conversational, semantic)
- Add aisbf.json for server configuration (host, port, dashboard auth)
- Update main.py to read server config from aisbf.json
- Update providers.json with max_context example for condensation

- Changed autoselect prompt from single user message to system+user split
- System message contains the skill instructions
- User message contains the prompt and model list
- Set temperature to 0 for deterministic selection
- Added stop parameter: </aisbf_model_autoselection>
- Updated internal model handling to combine messages

- Centralized API key storage in providers.json only
- Added support for provider-only rotation entries (auto-selects random model)
- Added default settings hierarchy at provider and rotation levels
- Limited autoselect selection context to 10 messages or 8000 tokens
- Added support for direct provider models in autoselect (rotation/provider/model)
- Added 'internal' keyword for local HuggingFace model selection
- Updated requirements.txt with torch and transformers

- Integrated complete kiro-gateway conversion pipeline (1,522 lines)
- Added multi-source authentication (Kiro IDE, kiro-cli, env vars)
- Implemented full OpenAI <-> Kiro format conversion
- Added support for tools/function calling
- Added support for images/multimodal content
- Implemented message merging, validation, and role normalization
- Added KiroAuthManager for automatic token refresh
- Created comprehensive conversion modules:
  - aisbf/kiro_converters.py (core conversion logic)
  - aisbf/kiro_converters_openai.py (OpenAI adapter)
  - aisbf/kiro_models.py (data models)
  - aisbf/kiro_auth.py (authentication)
  - aisbf/kiro_utils.py (utilities)
- Updated KiroProviderHandler with full conversion pipeline
- Added kiro_config support to ProviderConfig
- Updated providers.json with clean Kiro examples
- Added comprehensive documentation (KIRO_INTEGRATION.md)
- Implemented model name prefixing across all providers (provider_id/model)

No external kiro-gateway server needed - all functionality built-in.

Fix Google provider tool formatting - pass function declarations directly instead of wrapping in dict

Changed line 511 to check list length instead of boolean evaluation.
This fixes the bug where tool calls extracted from Google chunks were not being
sent to clients because empty lists were being treated as falsy.

Before: 'tool_calls': delta_tool_calls if delta_tool_calls else None
After:  'tool_calls': delta_tool_calls if len(delta_tool_calls) > 0 else None

- Added extraction of function_call from Google chunk parts
- Convert Google function_call to OpenAI-compatible tool_calls format
- Track accumulated_tool_calls to calculate deltas
- Include tool_calls in the delta when present
- Send chunks when there are new tool calls, not just text

- Removed stray 'd' identifier on line 494
- Fixed indentation issues on lines 494 and 537
- File now compiles without errors

- Fixed tool conversion to create single function_declarations array
- This prevents Google from detecting malformed tool use
- Tools are now properly converted from OpenAI to Google format

Improve error message formatting by replacing semicolon separators with newlines for better readability

- Detect and unwrap responses wrapped in 'assistant: [{"type": "text", "text": "..."}]' format
- Use extracted text for response content instead of raw accumulated text
- Fix variable scoping issue with tool_match variable
- Update token counting to use final_text when available

Instead of collecting all chunks and sending a modified response:
- Stream chunks normally as they come (with deltas like before)
- Only at the END, if tool call pattern detected, send additional chunk with tool_calls
- Then send final chunk with usage statistics

This preserves the original streaming behavior while adding tool call detection.

When the model returns a response in the format:
assistant: [{'type': 'text', 'text': '...'}]
but without a tool call, extract just the text content
instead of returning the raw wrapper format.

The model returns literal \n (backslash-n) instead of actual newlines.
This breaks JSON parsing because {\n is not valid JSON syntax.
Use codecs.decode with 'unicode_escape' to convert escape sequences
to actual characters before parsing.

- Log accumulated response text (first 500 and last 200 chars)
- Log extracted tool JSON with length and byte details
- Log ASCII codes for first 20 chars to detect encoding issues
- Log JSON parse errors with position details
- Log success/failure of JSON parsing attempts

- Use brace counting for robust JSON extraction
- Try JSON first, then fix common issues (single quotes, trailing commas)
- Extract final assistant text using regex after tool JSON
- Remove complex nested parsing that was failing with escaped quotes

- Models may return single quotes instead of double quotes
- Fall back to ast.literal_eval when JSON parsing fails
- Handle both JSON and Python-style literals in streaming responses

- Detect tool calls in accumulated streaming text after all chunks received
- Parse nested 'assistant: [...]' format with tool calls inside
- Parse simple 'tool: {...}' format
- Convert detected tool calls to OpenAI-compatible format
- Send tool_calls in first chunk, then final assistant text
- Proper handling of finish_reason in final chunk

- Detect when entire response is wrapped in 'assistant: [...]'
- Parse nested 'tool: {...}' inside the assistant text
- Extract final assistant text from nested structure
- Handle multi-line JSON content with proper brace counting
- More robust parsing for complex nested formats

- Detect '"content": "..." } assistant: [...]' pattern
- Extract tool content and convert to write action
- Extract assistant text from JSON array
- Handle multi-line content with newlines
- More robust tool call detection for various text formats

- Detect 'tool: {...}' pattern in Google model text responses
- Parse and convert to OpenAI-compatible tool_calls format
- Extract assistant text from 'assistant: [...]' format if present
- Handle both 'action' and 'name' fields for tool identification
- Convert arguments to JSON string for OpenAI compatibility

This fixes issues where models return tool calls as text instead of
using proper function_call attributes.

- Google provider now yields raw chunk objects instead of pre-formatted SSE bytes
- The handlers.py handles the conversion to OpenAI-compatible format
- This fixes the issue where clients weren't receiving streaming responses

Note: Server must be restarted to pick up this change