open-index/open-npm huggingface dataset:
npm package: @google-cloud/debug-proxy-common
Description: Common module for Stackdriver Debugger proxies
Author: Google LLC
Latest version: 0.2.1

# Common Module for Stackdriver Debugger Proxies

**This is not an official Google product.** This library may be changed in
backwards-incompatible ways and is not subject to any SLA or deprecation policy.

This project is a common module for developers of Stackdriver Debugger proxies.
[Stackdriver Debugger][debug] is a feature of [Google Cloud Platform][gcp] that
lets users debug their applications in production, in real-time, without
stopping or pausing their apps. The Stackdriver Debugger proxies interface
between Stackdriver Debugger and various IDES, allowing users to debug using
Stackdriver Debugger from their favourite environment. You can use this
common module as a base to develop your own Stackdriver Debugger proxy.

### List of Stackdriver Debugger Proxies

- [Stackdriver Debugger to Chrome DevTools proxy][devtools]

### Sample Usage

Please check out some of the above Stackdriver Debugger proxies to see their
actual implementations. A high-level summary of features is provided below:

```js
stackdriver = require('cloud-debug-proxy-common');

class CustomDebugProxy {
  constructor() {
    this.debugProxy = new stackdriver.DebugProxy({
      debuggerId: 'debuggerId',
      sourceDirectory: './',
    });
  }

  // Call this to initialize your proxy.
  async initialize() {
    // Prompt the user to choose a keyFile, or leave blank to use the default.
    await this.debugProxy.setProjectByKeyFile();

    // Prompt the user to select a debuggee from the list.
    const debuggeeList = await this.debugProxy.getDebuggees();
    console.log(debuggeeList);
    this.debugProxy.setDebuggeeId(debuggeeList[0].id);

    // Listen for breakpoint changes.
    this.debugProxy.on('breakpointHit', () => {
      console.log('hit a breakpoint!');
    });
  }

  // Call this after your proxy is fully initialized.
  async pollForPendingBreakpoints() {
    while (true) {
      await this.debugProxy.updatePendingBreakpoints(true);
   }
  }

  // Call this when the user adds a breakpoint in the IDE.
  // This sample breakpoint has path, line, and condition properties.
  async setBreakpoint(breakpoint) {
    const stackdriverBreakpoint = await this.debugProxy.setBreakpoint({
      action: stackdriver.Action.CAPTURE,
      location: {
        path: breakpoint.path,
        line: breakpoint.line,
      },
      condition: breakpoint.condition,
    });
    return {
      path: stackdriverBreakpoint.location.path,
      line: stackdriverBreakpoint.location.line,
      condition: stackdriverBreakpoint.condition,
    };
  }
}
```

[debug]:    https://cloud.google.com/debugger/
[gcp]:      https://cloud.google.com/
[devtools]: https://github.com/GoogleCloudPlatform/cloud-debug-proxy-chrome-devtools
npm package: @google-cloud/synthetics-sdk-mocha
Description: NodeJS SDK for integrating with the Google Cloud Monitoring Synthetics product.
Author: Google Inc.
Latest version: 0.1.1

[![npm version](https://img.shields.io/npm/v/@google-cloud/synthetics-sdk-mocha.svg)](https://www.npmjs.com/package/@google-cloud/synthetics-sdk-mocha)

# Synthetics SDK Mocha

Note: This is an experimental package under active development. New releases may include breaking changes.

The Synthetics SDK Mocha is a framework that runs a provided mocha test suite, and returns a response that may be consumed by the Google Cloud Monitoring Synthetics.

## Installation

```
npm install --save @google-cloud/synthetics-sdk-mocha
```

## Usage With Cloud Function V2

Google Cloud Monitoring Synthetics requires a Cloud Function v2 target, and as such, this guide explains how to set up a simple Function that uses the `@google-cloud/synthetics-sdk-mocha` package that runs a basic mocha test that ensures that an http endpoint returns OK.

### Write Synthetic Function & Mocha Tests
```bash
$ npm init
$ npm install --save @google-cloud/synthetics-sdk-mocha
$ npm install --save @google-cloud/functions-framework

# This example uses...
# * chai as an expectation framework
# * node-fetch for http requests
$ npm install --save chai
$ npm install --save node-fetch
```

`index.js`
```javascript
// index.js
const functions = require('@google-cloud/functions-framework');
const GcmSynthetics = require('@google-cloud/synthetics-sdk-mocha');

/*
 * This is the server template that is required to run a synthetic monitor in
 * Google Cloud Functions.
 */

functions.http('SyntheticMochaSuite', GcmSynthetics.runMochaHandler({
    spec: `${__dirname}/mocha_tests.spec.js}`
}));
```

`./mocha_tests.spec.js`
```javascript
// This file is in the same file as index.js
const {expect} = require('chai');
const fetch = require('node-fetch');

it('pings my website', async () => {
  const url = '<<YOUR URL HERE>>'; // URL to send the request to
  const externalRes = await fetch(url);
  expect(externalRes.ok).to.be.true;
});
```

### Create Function and Synthetic Monitor

Deploy function using gcloud
```bash
$ gcloud functions deploy <<service-name>> --gen2 --runtime=nodejs18 --region=<<region>> --source=. --entry-point=SyntheticMochaSuite --trigger-http
```

The created function may now be used within the Google Cloud Monitoring Synthetics product, where you may set up periodic invocation of the function, who's output will result in metrics, logs, and alerts based off of the results of the test.

# Useful Links

* For a sample, see [mocha-url-ok](../../samples/mocha-url-ok/)
* For more information on Mocha, visit [mochajs.org](https://mochajs.org/)
* For documentation regarding Google Cloud Monitoring Synthetics, visit [cloud.google.com/monitoring/](https://cloud.google.com/monitoring/)
* For documentation on Cloud Functions, visit [https://cloud.google.com/functions](https://cloud.google.com/functions/docs/concepts/version-comparison#new-in-2nd-gen)
npm package: @google-github-actions/actions-utils
Description: Helpers and utilities that are shared among Google GitHub Actions
Author: Google LLC
Latest version: 0.8.10

# GitHub Actions Utils

This repository contains a list of helpers and utilities that are shared among
Google GitHub Actions. As this repository is primarily for internal use, **there
is no backwards-compatibility promise**.

We do not recommend taking a dependency on this repository.

**This is not an officially supported Google product, and it is not covered by a
Google Cloud support contract. To report bugs or request features in a Google
Cloud product, please contact [Google Cloud
support](https://cloud.google.com/support).**
npm package: @google-labs/breadboard-server
Description: Scaffolding for running Breadboard as a server
Author: Google Labs Team
Latest version: 0.1.17

# Breadboard Server

![Milestone](https://img.shields.io/badge/milestone-M0-red) ![Stability](https://img.shields.io/badge/stability-wip-green)

The purpose of this package is to provide scaffolding to bring up a Breadboard API endpoint with [Cloud Functions](https://cloud.google.com/functions).
npm package: @google-labs/core-kit
Description: A Breadboard Kit containing nodes that enable composition and reuse of boards.
Author: Google Labs Team
Latest version: 0.19.1

# Breadboard Core Kit

![Stability](https://img.shields.io/badge/stability-wip-green)

A Kit containing components that enable composition and reuse of boards.

See [docs](https://breadboard-ai.github.io/breadboard/docs/kits/core/) for the component reference.
npm package: @google-labs/create-breadboard
Description: A starter kit for your Breadboard projects
Author: Google Labs Team
Latest version: 1.0.13

# npm init @google-labs/breadboard your-project-name

This project will quickly create a neat new project for you to start working on.

You can create and edit boards directly in the src/boards folder.

Note: If you are testing locally without publishing the module, then you need to `npm i` in the root before using.

## Usage

If you are running from inside the breadboard repo, and you want to use the latest versions of breadboard (i.e. not the published versions) then you _MUST_ use the `--workspace` command.

```bash
npm init @google-labs/breadboard ../testing --workspace=./packages/create-breadboard
```

This will create a new project in the `../testing` folder relative to the `./packages/create-breadboard` folder.

If you are running from outside the breadboard repo, then you can run:

```bash
npm init @google-labs/breadboard your-project-name
```

This will install `@google-labs/breadboard` from npm and create a new project in the `your-project-name` folder.
npm package: @google-labs/create-breadboard-kit
Description: A starter kit for your breadboard kits
Author: Google Labs Team
Latest version: 0.0.14

# npm init @google-labs/breadboard-kit your-project-name

This project will quickly create a simple Breadboard Kit project for you to start working on.

Note: If you are testing locally without publishing the module, then you need to `npm i` in the root before using.
npm package: @google-labs/json-kit
Description: A Breadboard Kit containing nodes that facilitate wrangling JSON objects
Author: Google Labs Team
Latest version: 0.3.17

# Breadboard JSON Kit

![Stability](https://img.shields.io/badge/stability-wip-green)

A kit containing components that help wrangle JSON.

See [docs](https://breadboard-ai.github.io/breadboard/docs/kits/json/) for the component reference.
npm package: @google-labs/llm-starter
Description: LLM Starter Kit for the Breadboard library
Author: Google Labs Team
Latest version: 0.3.15

# LLM Starter Kit

> [!WARNING]
> This kit is deprecated and will be removed soon.

The nodes that were in this kit are now part of other kits:

- [google-labs/core-kit](https://github.com/breadboard-ai/breadboard/tree/main/packages/core-kit)
  - `runJavascript`
  - `fetch`
  - `secrets`
- [google-labs/json-kit](https://github.com/breadboard-ai/breadboard/tree/main/packages/json-kit)
  - `jsonata`
  - `xmlToJson`
- [google-labs/template-kit](https://github.com/breadboard-ai/breadboard/tree/main/packages/template-kit)

  - `promptTemplate`
  - `urlTemplate`

  Thank you, LLM Starter Kit. You were the first kit ever made and we're forever grateful for showing us the way.
npm package: @google-labs/palm-kit
Description: A Breadboard Kit with nodes to access PaLM APIs.
Author: Google Labs Team
Latest version: 0.1.11

# Breadboard PaLM Kit

> [!NOTICE]
> The PaLM API is now deprecated. See https://ai.google.dev/palm_docs for more.

![Stability](https://img.shields.io/badge/stability-wip-green) [![Discord](https://img.shields.io/discord/1138546999872999556?logo=discord)](https://discord.gg/breadboard)

A Breadboard Kit with nodes to access PaLM APIs.

## Node Reference

This kit contains the following nodes:

### The `generateText` node

This is a [PaLM API](https://developers.generativeai.google/) text completion node. To produce useful output, the node needs a `PALM_KEY` input and the `text` input.

#### Example:

Given this input:

```json
{
  "PALM_KEY": "<your API key>",
  "text": "How old is planet Earth?"
}
```

The node will produce this output:

```json
{
  "completion": "It is about 4.5 billion years old."
}
```

#### Inputs:

- `PALM_KEY` required, must contain the Google Cloud Platform API key for the project has the "Generative Language API" API enabled.
- `text` required, sent as the prompt for the completion.
- `stopSequences` optional array of strings. These will be passed as the stop sequences to the completion API.

#### Outputs:

- `completion` - result of the PaLM API text completion.

### The `embedText` node

This is a [PaLM API](https://developers.generativeai.google/) text embedding node. Just like the `generateText` node, it needs a `PALM_KEY` input and the `text` input.

#### Example:

Given this input:

```json
{
  "PALM_KEY": "<your API key>",
  "text": "How old is planet Earth?"
}
```

The node will output a 768-dimensional embedding of the text:

```json
{
  "embedding": [0.1, ... ]
}
```

#### Inputs:

- `PALM_KEY` required, must contain the Google Cloud Platform API key for the project has the "Generative Language API" API enabled.

- `text` required, text to embed.

#### Outputs:

- `embedding` - result of the PaLM API text embedding, a 768-dimensional array of floating-point numbers.
npm package: @google-labs/pinecone-kit
Description: A collection of Breadboard nodes for working with Pinecone
Author: Google Labs Team
Latest version: 0.1.12

# A Breadboard Kit for Pinecone

This kit is a an early prototype, and is very likely to change. However, it should give pretty good idea on how to build kits with boards.

There are currently four boards that power this kit:

- [`config`](src/boards/config.ts), which handles configuration of the Pinecone API, and is represented by the `config` node.

- [`vector`](src/boards/vector.ts), which is a thin wrapper around the [vector operations](https://docs.pinecone.io/reference/vector-operations), and is represented by the `vector` node.

- [`upsert`](src/boards/upsert.ts), which uses the `config` and `vector` boards above to call Pinecone [upsert API](https://docs.pinecone.io/reference/upsert), and is represented by the `upsert` node.

- [`query`](src/boards/query.ts), which uses the `config` and `vector` boards to call Pinecone [query API](https://docs.pinecone.io/reference/query), and is represented by the `query` node.

To load this kit into your board, run:

```bash
npm i @google-labs/pinecone-kit
```

Then, in your board, add the following:

```ts
import { Pinecone } from "@google-labs/pinecone-kit";

// Add the kit to some existing `board`.
const pinecone = board.addKit(Pinecone);

// This is the `query` node.
const query = pinecone.query();
```

The `config` and `vector` node can be used to call other vector operations.