mirror of
https://github.com/googleapis/genai-toolbox.git
synced 2026-01-10 07:58:12 -05:00
967a72da11
This PR update the linking mechanism between Source and Tool.
Tools are directly linked to their Source, either by pointing to the
Source's functions or by assigning values from the source during Tool's
initialization. However, the existing approach means that any
modification to the Source after Tool's initialization might not be
reflected. To address this limitation, each tool should only store a
name reference to the Source, rather than direct link or assigned
values.
Tools will provide interface for `compatibleSource`. This will be used
to determine if a Source is compatible with the Tool.
```
type compatibleSource interface{
Client() http.Client
ProjectID() string
}
```
During `Invoke()`, the tool will run the following operations:
* retrieve Source from the `resourceManager` with source's named defined
in Tool's config
* validate Source via `compatibleSource interface{}`
* run the remaining `Invoke()` function. Fields that are needed is
retrieved directly from the source.
With this update, resource manager is also added as input to other
Tool's function that require access to source (e.g.
`RequiresClientAuthorization()`).
134 lines
3.4 KiB
Go
134 lines
3.4 KiB
Go
// Copyright 2025 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
package cloudmonitoring
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/http"
|
|
|
|
"github.com/goccy/go-yaml"
|
|
"github.com/googleapis/genai-toolbox/internal/sources"
|
|
"github.com/googleapis/genai-toolbox/internal/util"
|
|
"go.opentelemetry.io/otel/trace"
|
|
"golang.org/x/oauth2"
|
|
"golang.org/x/oauth2/google"
|
|
monitoring "google.golang.org/api/monitoring/v3"
|
|
)
|
|
|
|
const SourceKind string = "cloud-monitoring"
|
|
|
|
// validate interface
|
|
var _ sources.SourceConfig = Config{}
|
|
|
|
func init() {
|
|
if !sources.Register(SourceKind, newConfig) {
|
|
panic(fmt.Sprintf("source kind %q already registered", SourceKind))
|
|
}
|
|
}
|
|
|
|
func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources.SourceConfig, error) {
|
|
actual := Config{Name: name}
|
|
if err := decoder.DecodeContext(ctx, &actual); err != nil {
|
|
return nil, err
|
|
}
|
|
return actual, nil
|
|
}
|
|
|
|
type Config struct {
|
|
Name string `yaml:"name" validate:"required"`
|
|
Kind string `yaml:"kind" validate:"required"`
|
|
UseClientOAuth bool `yaml:"useClientOAuth"`
|
|
}
|
|
|
|
func (r Config) SourceConfigKind() string {
|
|
return SourceKind
|
|
}
|
|
|
|
// Initialize initializes a Cloud Monitoring Source instance.
|
|
func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
|
|
ua, err := util.UserAgentFromContext(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error in User Agent retrieval: %s", err)
|
|
}
|
|
|
|
var client *http.Client
|
|
if r.UseClientOAuth {
|
|
client = &http.Client{
|
|
Transport: util.NewUserAgentRoundTripper(ua, http.DefaultTransport),
|
|
}
|
|
} else {
|
|
// Use Application Default Credentials
|
|
creds, err := google.FindDefaultCredentials(ctx, monitoring.MonitoringScope)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to find default credentials: %w", err)
|
|
}
|
|
baseClient := oauth2.NewClient(ctx, creds.TokenSource)
|
|
baseClient.Transport = util.NewUserAgentRoundTripper(ua, baseClient.Transport)
|
|
client = baseClient
|
|
}
|
|
|
|
s := &Source{
|
|
Config: r,
|
|
baseURL: "https://monitoring.googleapis.com",
|
|
client: client,
|
|
userAgent: ua,
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
var _ sources.Source = &Source{}
|
|
|
|
type Source struct {
|
|
Config
|
|
baseURL string
|
|
client *http.Client
|
|
userAgent string
|
|
}
|
|
|
|
func (s *Source) SourceKind() string {
|
|
return SourceKind
|
|
}
|
|
|
|
func (s *Source) ToConfig() sources.SourceConfig {
|
|
return s.Config
|
|
}
|
|
|
|
func (s *Source) BaseURL() string {
|
|
return s.baseURL
|
|
}
|
|
|
|
func (s *Source) Client() *http.Client {
|
|
return s.client
|
|
}
|
|
|
|
func (s *Source) UserAgent() string {
|
|
return s.userAgent
|
|
}
|
|
|
|
func (s *Source) GetClient(ctx context.Context, accessToken string) (*http.Client, error) {
|
|
if s.UseClientOAuth {
|
|
if accessToken == "" {
|
|
return nil, fmt.Errorf("client-side OAuth is enabled but no access token was provided")
|
|
}
|
|
token := &oauth2.Token{AccessToken: accessToken}
|
|
return oauth2.NewClient(ctx, oauth2.StaticTokenSource(token)), nil
|
|
}
|
|
return s.client, nil
|
|
}
|
|
|
|
func (s *Source) UseClientAuthorization() bool {
|
|
return s.UseClientOAuth
|
|
}
|