Sanitize prompts and responses

  curl -X POST \
      -d '{"userPromptData":{"text":"[UNSAFE TEXT]"}}' \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $(gcloud auth print-access-token)" \
      "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID:sanitizeUserPrompt"

  {
  "sanitizationResult": {
    "filterMatchState": "MATCH_FOUND",
    "invocationResult": "SUCCESS",
    "filterResults": {
      "csam": {
        "csamFilterFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "NO_MATCH_FOUND"
        }
      },
      "malicious_uris": {
        "maliciousUriFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "NO_MATCH_FOUND"
        }
      },
      "rai": {
        "raiFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "MATCH_FOUND",
          "raiFilterTypeResults": {
            "sexually_explicit": {
              "matchState": "NO_MATCH_FOUND"
            },
            "hate_speech": {
              "matchState": "NO_MATCH_FOUND"
            },
            "harassment": {
              "matchState": "NO_MATCH_FOUND"
            },
            "dangerous": {
              "matchState": "MATCH_FOUND"
            }
          }
        }
      },
      "pi_and_jailbreak": {
        "piAndJailbreakFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "MATCH_FOUND"
        }
      },
      "sdp": {
        "sdpFilterResult": {
          "inspectResult": {
            "executionState": "EXECUTION_SUCCESS",
            "matchState": "NO_MATCH_FOUND"
          }
        }
      }
    }
  }
  }
  

  sanitization_result {
    filter_match_state: MATCH_FOUND
    filter_results {
      key: "rai"
      value {
        rai_filter_result {
          execution_state: EXECUTION_SUCCESS
          match_state: MATCH_FOUND
          rai_filter_type_results {
            key: "dangerous"
            value {
              confidence_level: HIGH
              match_state: MATCH_FOUND
            }
          }
        }
      }
    }
    filter_results {
      key: "pi_and_jailbreak"
      value {
        pi_and_jailbreak_filter_result {
          execution_state: EXECUTION_SUCCESS
          match_state: MATCH_FOUND
          confidence_level: HIGH
        }
      }
    }
    filter_results {
      key: "malicious_uris"
      value {
        malicious_uri_filter_result {
          execution_state: EXECUTION_SUCCESS
          match_state: NO_MATCH_FOUND
        }
      }
    }
    filter_results {
      key: "csam"
      value {
        csam_filter_filter_result {
          execution_state: EXECUTION_SUCCESS
          match_state: NO_MATCH_FOUND
        }
      }
    }
    invocation_result: SUCCESS
  }
  

package main

import (
  "context"
  "fmt"
  "io"
  "log"

  modelarmor "cloud.google.com/go/modelarmor/apiv1beta"
  modelarmorpb "cloud.google.com/go/modelarmor/apiv1beta/modelarmorpb"
  "google.golang.org/api/option"
  "google.golang.org/protobuf/encoding/protojson"
)

func main() {
  ctx := context.Background()

  // Define variables for project, location, and template ID
  projectID := "YOUR_PROJECT_ID"
  location := "LOCATION_ID"
  templateID := "YOUR_TEMPLATE_ID"

  // 1. Create the client with the custom regional endpoint.
  opts := option.WithEndpoint("modelarmor.us-central1.rep.googleapis.com:443")
  c, err := modelarmor.NewClient(ctx, opts)
  if err != nil {
    log.Fatalf("failed to create client: %v", err)
  }
  defer c.Close()

  // 2. Start the StreamSanitizeUserPrompt bidirectional stream.
  stream, err := c.StreamSanitizeUserPrompt(ctx)
  if err != nil {
    log.Fatalf("failed to initialize stream: %v", err)
  }

  // 3. Use a goroutine to send the requests.
  go func() {

    // Define the user prompt data
    userPromptData := &modelarmorpb.DataItem{
      DataItem: &modelarmorpb.DataItem_Text{
                          // Specify the user prompt.
        Text: "This is a sample user prompt",
      },
    }

    // Create the request object
    req := &modelarmorpb.SanitizeUserPromptRequest{ // Use fmt.Sprintf to construct the resource name
      Name:           fmt.Sprintf("projects/%s/locations/%s/templates/%s", projectID, location, templateID),
      UserPromptData: userPromptData,
    }

    reqs := []*modelarmorpb.SanitizeUserPromptRequest{req}

    for _, r := range reqs {
      if err := stream.Send(r); err != nil {
        log.Printf("Failed to send request: %v", err)
        return
      }
    }

    stream.CloseSend()
  }()

  // 4. Iterate over the responses from the stream.
  for {
    resp, err := stream.Recv()
    if err == io.EOF {
      break
    }
    if err != nil {
      log.Fatalf("failed to receive response: %v", err)
    }

    // Marshal the proto message to a formatted JSON string
    b, _ := protojson.MarshalOptions{
      Multiline: true,
      Indent:    "  ",
    }.Marshal(resp)

    // Results can be consumed or assigned here in production workflows
  }
}

  using Google.Api.Gax.Grpc;
  using Google.Cloud.ModelArmor.V1Beta;
  using Grpc.Core;
  using System;
  using System.Collections.Generic;
  using System.Threading.Tasks;

  public class StreamSanitizeUserPromptExample
  {
  public static async Task Main(string[] args)
      {
          try
          {
              await RunStreamSanitizeUserPromptExample();
          }
          catch (Exception e)
          {
              Console.WriteLine($"An error occurred: {e}");
          }
      }
      public static async Task RunStreamSanitizeUserPromptExample()
      {
          string projectId = "YOUR_PROJECT_ID";
          string location = "LOCATION_ID";
          string templateId = "YOUR_TEMPLATE_ID";

          var promptChunks = new List<string>
          {
              "This is the first part of the user prompt. ",
              "This is the second part. ",
              "And this is the final part."
          };

          // Construct the regional REP endpoint (without port)
          string regionalEndpoint = $"modelarmor.{location}.rep.googleapis.com";
          Console.WriteLine($"Using endpoint: {regionalEndpoint}");

          // Initialize the Model Armor client using Application Default Credentials.

          var client = new ModelArmorClientBuilder
          {
              Endpoint = regionalEndpoint
          }.Build();

          // Construct the resource name.
          var resourceName = TemplateName.FromProjectLocationTemplate(projectId, location, templateId);

          // Get the bi-directional streaming call object
          using var stream = client.StreamSanitizeUserPrompt();

          Console.WriteLine("Sending requests...");

          // --- Send First Request ---
          var firstRequest = new SanitizeUserPromptRequest
          {
              Name = resourceName.ToString(),
              UserPromptData = new DataItem { Text = promptChunks[0] },
              StreamingMode = StreamingMode.Buffered // Or StreamingMode.Realtime
          };
          await stream.WriteAsync(firstRequest);
          Console.WriteLine($"Sent chunk 1: \"{promptChunks[0]}\"");

        // --- Send Subsequent Requests ---
          for (int i = 1; i < promptChunks.Count; i++)
          {
              var subsequentRequest = new SanitizeUserPromptRequest
              {
                  Name = resourceName.ToString(),
                  UserPromptData = new DataItem { Text = promptChunks[i] }
              };
              await stream.WriteAsync(subsequentRequest);
              Console.WriteLine($"Sent chunk {i + 1}: \"{promptChunks[i]}\"");
          }

        // Signal that the client has finished sending requests.
          await stream.WriteCompleteAsync();
          Console.WriteLine("Client finished sending.");

        // --- Receive Responses ---
          Console.WriteLine("Receiving responses...");
        // This loop waits for responses until the server closes the stream.
          while (await stream.GetResponseStream().MoveNextAsync())
          {
              SanitizeUserPromptResponse response = stream.GetResponseStream().Current;
              if (response.SanitizationResult != null)
              {
                  var result = response.SanitizationResult;
                  Console.WriteLine("Received response:");
                  Console.WriteLine($"  Match State: {result.FilterMatchState}");
                  Console.WriteLine($"  Invocation Result: {result.InvocationResult}");
              }
              else
              {
                  Console.WriteLine("Received empty response.");
              }
          }
          Console.WriteLine("Stream finished and closed.");
      }
  }

package com.example.armor;

import com.google.api.gax.rpc.BidiStream;
import com.google.cloud.modelarmor.v1beta.DataItem;
import com.google.cloud.modelarmor.v1beta.ModelArmorClient;
import com.google.cloud.modelarmor.v1beta.ModelArmorSettings;
import com.google.cloud.modelarmor.v1beta.SanitizationResult;
import com.google.cloud.modelarmor.v1beta.SanitizeUserPromptRequest;
import com.google.cloud.modelarmor.v1beta.SanitizeUserPromptResponse;
import com.google.cloud.modelarmor.v1beta.StreamingMode;
import com.google.cloud.modelarmor.v1beta.TemplateName;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;

public class StreamSanitizeUserPrompt {

    public static void main(String[] args) {
        try {
            streamSanitizeUserPromptExample();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void streamSanitizeUserPromptExample()
            throws IOException, InterruptedException, ExecutionException {

  // Specify the Google Project ID.
String projectId = "YOUR_PROJECT_ID";
// Specify the location ID. For example, us-central1.
String locationId = "LOCATION_ID";
// Specify the template ID.
String templateId = "YOUR_TEMPLATE_ID";
      String customApiEndpoint = "modelarmor.us-central1.rep.googleapis.com:443";

        List<String> promptChunks = Arrays.asList(
                "This is the first part of the user prompt. ",
                "This is the second part. ",
                "And this is the final part."
        );

        // ModelArmorSettings is now properly imported and recognized here
        try (
            ModelArmorClient modelArmorClient = ModelArmorClient.create(
                ModelArmorSettings.newBuilder()
                        .setEndpoint(customApiEndpoint)
                        .build()
            )
        ) {

            BidiStream<SanitizeUserPromptRequest, SanitizeUserPromptResponse> stream =
                    modelArmorClient.streamSanitizeUserPromptCallable().call();

            String resourceName = TemplateName.of(projectId, locationId, templateId).toString();

            // --- Send First Request ---
            SanitizeUserPromptRequest firstRequest = SanitizeUserPromptRequest.newBuilder()
                    .setName(resourceName)
                    .setUserPromptData(DataItem.newBuilder().setText(promptChunks.get(0)))
                    .setStreamingMode(StreamingMode.STREAMING_MODE_BUFFERED)
                    .build();
            stream.send(firstRequest);

            // --- Send Subsequent Requests ---
            for (int i = 1; i < promptChunks.size(); i++) {