Actions

Actions are endpoint documentation, it outlines what an endpoint can do, how much it costs, how to use it and how to set it up. The end goal is for Colibri to be able to use these Actions on its own or though Stacks to perform any result the user desiers.

Task Chat Branch API

Status & Details

note

These details are only updated with each release, for more acurate updates and keeping track of progress, see the task in GitHub.

Development Status

Doc	Backend	Frontend	Last Update
In Progress	Revisions	-	04.03.2024

Release Status

Version	Channel	Phase
0.01	Internal	Alpha

Team

Owner	Lead
Mendy	Sergey

Description

There are a few types of Actions (internal, system, marketplace, private and public). Internal, these are actions that can only be used by Colibri (and its employees).

System, are Actions that are used to manage/update system related endpoints.

Local to update and manage in app things like navigat to, etc

Utilities to manage and update device like flash, blurtooth, etc.

Marketplace are actions with data we should not call directly but through our builtin marketplace, (e.g. rent a car should not call an action to show all data from that action but rather all car rental actions and rought the data through the marketplace).

Private: allow Enterprise clients to upload thier own Actions and keep them private to be used only internaly for thier own company. They can always switch to publish.

Publish these are actions sold by publishers and avalible to Colibri to use for all users.

Reminders

Links & Resources

Phases

Phases

Here are the goals and steps we will take to develop the Action feature.

Phase One

• Use Gemini to Inport Actions.

Phase Two

• Move actions to BackBone,
• Connet Colibri backend to BackBone API

Phase Three

• Use BackBone to generate Actions when none can be imported
• Get BackBone to build Publisher, when an action or API is published to BackBone it is also on Colibri and vs.

Phase Four

Research

Research

note

the research listed here is spesifict to the User (Account) feature, for research related to the general BackBone development see the Research document.

In the course of our research, we discovered many tools that will help us achieve the project goal. This document contains the research that was done for both, thus it is the [** Project**] Research. To read about the conclusions drawn from the research one should read the complete Project Description and its accompanying documents.

Technical

---

Question - How do we handle actions that need data from the users account? Answer -

Question - How do we seperate data per user when it is not coming from another account the user has? Answer -

Question - Answer -

Question - Answer -

Conclusion -

Sources

• [test]

---

Business

User Focused

User Stories

Persona One

Update Coming Soon

As a busy user I don’t want to watch but rather listen to a podcast, however, when I hear a voice I don’t recognize, I want to take a glance at my phone to see a name and/or photo of who is talking or maybe ask the built-in “AI/assistant”.

Features & Functions

Features

Below is a list of features that will be utilized in order to deliver the best account features and functionalities. The details bellow are not comprehensive feature details but rather, describe how the features will be utilized within the account, for further details, please see the individual feature documentation.

Dependent Features

• Libraries

  The Library feature is needed to support how we store Actions.

• [Publisher]

  In order for Actions to be truly succesful we will need the Publisher flow for Publishers (developers) to release tier own Actions.

• Access

  Each Action will need varius Access docs, first for the publisher to have admin access, another to determin the release access e.g. draft, public, etc.

• [Feedback]

  each action must accet feedback and scoring to determin its usfulness thus we will need the feedback feature

• [Flags]

  we should be able to flag actions for danger, privacy and other issues

Succesors

• Stacks

a Stack chooses the right actions and orders them in a sequance with pauses and user or data imputs to acomplish the user goals, A stack should also take feedback from the Flow and teh user to adapt.

• [Vibe This]

a vice coder that doesnt write code

Data

An Actions needs to hold two types of data, the action details and how to use the action, the data it can provide, etc.

Action

- action (Collection)
  - actionId (UUID / Document)
  - type (Enum: internal, system, marketplace, private, public)
  
  - listing
    - displayName (String)
    - system_name (String)
    - publisherId (Reference)
    - status (Enum: draft, private, beta, public, deprecated)
    - description (Text)
    - category (e.g., Travel)
    - industry (e.g., transport, retail)
    - supportedLanguages (Array: ['en', 'es'])
    - dangerous (Enum: low, medium, high)
    - createdAt (Timestamp)
    - createdBy (String: ColibriId, auto, accountId)
    - ai_generated_review_summary (Text - optional summary for marketplace)

  - unified_health_score
    - confidence (Float: 0.0 to 1.0. Used by the LLM Router to trust/pick this action)
    - total_signals_processed (Integer)
    - real_time_signals
      - ai_grader_accuracy_avg (Float)
      - telemetry_success_rate (Float)
    - long_term_signals
      - statistical_blame_weight (Float)
      - isolation_status (Enum: healthy, under_review, quarantined)

  - documentation
    - requiresConnection (Boolean: true/false)
    - type (e.g., REST, GraphQL, Webhook)
    - authType (Enum: oauth2, apiKey, bearer, none)
    - requiredPermissions (Array of scopes)
    - useCases (Array of strings for LLM embedding/matching)
    - capabilities (Array of tags/features)
    - docsUrl (String)
    - documentId (String)
    - version (String)

  - execution 
    - baseUrl (String)
    - path (String: e.g., /v1/flights/search)
    - method (Enum: GET, POST, PUT, DELETE)
    - timeout_ms (Integer)
    - schemas
      - queryParamsSchema (JSON Schema)
      - requestBodySchema (JSON Schema)
      - responseSchema (JSON Schema)

  - pricing
    - costs (Array or Map)
      - costId
        - price (Float)
        - currency (String)
        - credits (Integer)
        - setBy (String)
        - rate_limit_tiers (JSON / String)
    - markup (Array or Map)
      - markupId
        - percent (Float)
        - base_price
          - currency (String)
          - credits (Integer)
        - market_price
          - currency (String)
          - credits (Integer)
        - setBy (Enum: default, auto, colibriId, publisherId)

Stats

In the Stats collection have the follow states rlated to Actions

- action_stats
  - actionId (String: Foreign Key)
  - usage
    - total_calls (Integer)
    - success_rate (Percentage)
    - avg_latency_ms (Integer)
  - financials
    - total_revenue_usd (Float)
    - total_credits_spent (Integer)
    - publisher_payouts_pending (Float)
  - reports
    - error_logs (Array of JSON: recent 5XX details)
    - user_flags (Array of JSON: Safety/complaint reports)

Reviews

in the reviews collection add

- action_review
  - reviewId (UUID)
  - actionId (String: Foreign Key)
  - sessionId (String)
  - reviewerType (Enum: 'user', 'system_telemetry', 'ai_grader')
  - feedback_data
    - source (Enum: 'explicit_thumbs', 'explicit_stars', 'implicit_error', 'ai_analysis')
    - rating_value (Integer/Float)
    - user_selected_tags (Array of Strings)
    - raw_user_comment (Text)
  - ai_generated_summary
    - evaluation_reasoning (Text)
    - confidence_in_blame (Float)
  - context_snapshot
    - execution_latency_ms (Integer)
    - http_status_returned (Integer)
    - request_payload_snippet (JSON)
    - response_payload_snippet (JSON)
  - createdAt (Timestamp)

Performance

in the performance collection add

- action_co_occurrence
  - coOccurrenceId (UUID)
  - primaryActionId (String: Foreign Key)
  - pairedActionIds (Array of Strings)
  - sessionCount (Integer)
  - negativeFeedbackCount (Integer)
  - calculated_blame_weight (Float)

Gemini