Extended OpenAI Conversation

The edit_file function follows a strict read-modify-write lifecycle to ensure safety:

1. File Read: The entire file is read into memory to verify existence.
2. Exact Match Search: It searches for an exact string match of old_text (including whitespace, case sensitivity, and special characters).
3. Occurrence Validation:
   • If old_text is found 0 times $\rightarrow$ Error: "Text not found in file".
   • If old_text is found 1 time $\rightarrow$ Proceed.
   • If old_text is found 2+ times $\rightarrow$ Error: "Text appears N times in file".
4. Atomic Replacement: The single occurrence is replaced with new_text and the file is written back. If any step fails, the file remains unchanged.

Return Values

On Success:

{
  "success": true,
  "path": "/config/extended_openai_conversation/config.yaml",
  "replacements": 1
}

On Error:

{
  "error": "Text not found in file: old text here..."
}

OR

{
  "error": "Text appears 3 times in file. Please provide more specific text to ensure single replacement."
}

You can control which attributes of a Home Assistant entity are exposed to the LLM by defining a customize_glob_exposed_attributes dictionary. This works similarly to Home Assistant's customize_glob and uses regular expressions (regex) to match entity IDs.

Logic for attribute inclusion:

• Boolean true: The actual value of the attribute from the entity is included.
• Boolean false: The attribute is excluded.
• Non-boolean value: The specific value you provide in the dictionary is included instead of the actual attribute value from the entity.

This allows you to filter sensitive data or provide specific context (like a list of allowed media sources) to the model.

{%- set customize_glob_exposed_attributes = {
  ".*": {
    "friendly_name": true,
  },
  "timer\..*": {
    "duration": true,
  },
  "sun.sun": {
    "next_dawn": true,
    "next_midnight": true,
  },
  "media_player.YOUR_WEBOS_TV": {
    "source_list": ["Netflix","YouTube","wavve"],
    "source": true,
  },
}
%}

Template functions support standard Home Assistant Jinja2 features. Common patterns include:

• Accessing Entity States: Using states('entity_id'), states.domain.object.state, or state_attr('entity_id', 'attribute').
• Filtering and Selecting: Using filters like selectattr to find entities in specific states.
• Date and Time: Using now() and related time functions.
• Math and Logic: Performing calculations and conditional logic (if/else).

{# Access Entity States #}
{{ states('sensor.temperature') }}
{{ states.sensor.temperature.state }}
{{ state_attr('sensor.temperature', 'unit_of_measurement') }}

{# Filter and Select #}
{% set on_lights = states.light | selectattr('state', 'eq', 'on') | list %}
{{ on_lights | length }} lights are on

{# Date and Time #}
{{ now() }}
{{ now().strftime('%Y-%m-%d %H:%M:%S') }}
{{ as_timestamp(now()) }}

{# Math and Logic #}
{% set total = (value1 | float) + (value2 | float) %}
{% if total > 100 %}High{% else %}Normal{% endif %}

A composite function type allows you to execute a sequence of operations (e.g., multiple SQL queries and a template step) to produce a single result.

In a sequence:

1. Use type: sqlite to run queries. Use response_variable to store the result of a query for use in subsequent steps.
2. Use type: template with a value_template to process the variables collected from previous steps into a final response format.

- spec:
    name: get_states_between
    description: >
      Use this function to get non-numeric states between two dates.
    parameters:
      type: object
      properties:
        entity_id:
          type: string
          description: The target entity
        # ... other properties ...
      required:
        - entity_id
        - start_datetime
        - end_datetime
        - order
        - page
        - limit
  function:
    type: composite
    sequence:
      - type: sqlite
        query: >-
          # ... SQL query using {{parameters}} ...
        response_variable: data
      - type: sqlite
        single: true
        query: >-
          # ... SQL query to get count ...
        response_variable: total
      - type: template
        value_template: '{"data": {{data}}, "total": {{total.count}}}'

Functions are the primary way to extend your AI assistant's capabilities. Every function is defined using a two-part structure consisting of a spec (the AI's interface) and a function (the execution logic).

1. spec: Follows the OpenAI function schema format. It tells the AI what the function is and how to call it. It includes:

   • name: The identifier the AI uses to call the function.
   • description: A detailed explanation of the function's purpose (crucial for the AI to decide when to use it).
   • parameters: A JSON schema defining the expected input properties.

2. function: Defines how the action is actually performed. It includes:

   • type: The specific execution engine to use (e.g., native, rest, bash).
   • Type-specific configuration settings.

- spec:
    name: function_name
    description: What this function does
    parameters:
      type: object
      properties:
        param_name:
          type: string
          description: Parameter description
  function:
    type: function_type
    # Type-specific configuration

You can introduce a delay to any function call by adding a reserved delay parameter to the function's specification. This parameter allows you to specify a wait time before the function is executed. The delay parameter is an object containing hours, minutes, and seconds properties.

To implement this, include the delay object within the properties section of your function's parameters spec.

- spec:
    name: ...
    description: ...
    parameters:
      type: object
      properties:
        delay: # Add delay parameter to any function spec.
          type: object
          description: Time to wait before execution
          properties:
            hours:
              type: integer
              minimum: 0
            minutes:
              type: integer
              minimum: 0
            seconds:
              type: integer
              minimum: 0
        ...
  function:
    type: ...