github · fast-agentHEAD

WORKDIR /app

RUN apt-get update && apt-get install -y curl wget && \

    wget https://dl.min.io/client/mc/release/linux-amd64/mc -O /usr/local/bin/mc && \

    chmod +x /usr/local/bin/mc && \

    apt-get clean && rm -rf /var/lib/apt/lists/*

RUN pip install uv

# Copy dependency files only

COPY pyproject.toml /tmp/

#COPY uv.lock /tmp/

# Install dependencies

WORKDIR /tmp

RUN uv pip install --system .

# Switch back to /app (this will be overridden by volume mount)

WORKDIR /

self._queue.task_done()

                raise

            except Exception as e:

                # Mark task done for this event

                if event is not None and self._queue is not None:

                    self._queue.task_done()

self.conn = conn

    async def sessionUpdate(self, params):

    # Add other required methods...

elif key in {"q", "Q"}:  # Quit

                break

        except Exception as e:

            break

print_formatted_text(HTML("<b>Final selection</b>"))

    print_formatted_text(f"Resolved model: {resolved_model}")

    print(json.dumps(payload, indent=2))

# Example 2: Secure credential entry via tool call

        console.print("[bold yellow]Example 2: Secure Credential Entry[/bold yellow]")

        console.print(

        )

        result = await agent.send('***CALL_TOOL enter_api_key {"api_name": "OpenAI"}')

        panel = Panel(

            result,

return decorator

    async def signal(self, signal) -> None:

        handlers = self._handlers.get(signal.name, [])

        await gather_with_cancel(handler(signal) for handler in handlers)

print(

            f"Cache: read={turn_usage.cache_usage.cache_read_tokens}, write={turn_usage.cache_usage.cache_write_tokens}"

        )

        print(

            f"Accumulator: total_turns={self.usage_accumulator.turn_count}, cumulative_billing={self.usage_accumulator.cumulative_billing_tokens}, current_context={self.usage_accumulator.current_context_tokens}"

        )

),

    ).run()

    return 0

if issues:

            if elicitations:

                console.console.print(

                    f"MCP server {server_name} returned non-compliant URL elicitation payload:"

                    "[/yellow]"

                )

            else:

                console.console.print(

                    "[yellow]"

loop.run_in_executor(None, input, "Enter value: "), timeout_seconds

                )

            except asyncio.TimeoutError:

                raise

        else:

            value = await loop.run_in_executor(None, input, "Enter value: ")

_validate_json_payload(structured_text)

            print("structured JSON validated against supplied schema")

        except RequestError as exc:

            if exc.data is not None:

                print(json.dumps(exc.data, indent=2), file=sys.stderr)

            if exc.code == -32000:

)

async def main() -> None:

    console = Console(file=sys.stderr)

        "\n[bright_red]Router Workflow Demo[/bright_red]\n\n"

        "Enter a request to route it to the appropriate agent.\nEnter [bright_red]STOP[/bright_red] to run the demo, [bright_red]EXIT[/bright_red] to leave"

    )

    async with fast.run() as agent:

        await agent.interactive(agent_name="route")

# Print raw usage for debugging

        print(f"\n=== USAGE DEBUG ({turn_usage.model}) ===")

        print(f"Raw usage: {raw_usage}")

            f"Turn usage: input={turn_usage.input_tokens}, output={turn_usage.output_tokens}, current_context={turn_usage.current_context_tokens}"

        )

        print(

            f"Cache: read={turn_usage.cache_usage.cache_read_tokens}, write={turn_usage.cache_usage.cache_write_tokens}"

        )

# Example 1: OAuth-like authorization via tool call

        console.print("[bold yellow]Example 1: OAuth Authorization Flow[/bold yellow]")

        console.print("[dim]The server will request authorization for an external service.[/dim]\n")

        panel = Panel(

            result,

# Build schema for structured output

        schema = None

        try:

        except Exception:

            pass

        response_schema = model if schema is None else schema

        # Convert the last user message to provider-native content for the current turn

finally:

            self._runtime_context_loading.discard(model_id)

            try:

            except Exception:

                pass

    @classmethod

    def _model_row_label(

remaining_instances = list(self._server_managed_instances)

            for instance in remaining_instances:

                try:

                except Exception:

                    pass

            self._server_managed_instances.clear()

            return

try:

        sys.stderr.write(line)

        sys.stderr.flush()

    except Exception:

        pass

    try:

        fd = os.open("/dev/tty", os.O_WRONLY | os.O_NOCTTY)

except OSError:

        return None

    try:

    except Exception:

        pass

    return os.fdopen(tty_fd, "w", buffering=1, encoding="utf-8", errors="replace")