Merge branch 'main' into error-handling-in-repeat-1

Author: mandel

.github/workflows/rust-interpreter.yml

@@ -31,4 +31,8 @@ jobs:
             (curl -fsSL https://ollama.com/install.sh | sudo -E sh && sleep 2)
           wait
       - name: Run interpreter tests
-        run: npm run test:interpreter
+        run: |
+          python3.12 -mvenv venv
+          source venv/bin/activate
+          pip install nested-diff
+          npm run test:interpreter

.github/workflows/tauri-cli.yml

@@ -31,27 +31,20 @@ jobs:
             sudo apt install -y libgtk-3-dev libwebkit2gtk-4.1-dev librsvg2-dev patchelf at-spi2-core && \
             (curl -fsSL https://ollama.com/install.sh | sudo -E sh && sleep 2)
           wait
-      - name: Test production build
-        run: npm run tauri build -- --bundles deb # Skip testing appimage, is this dangerous? It's slow...
+      - name: Test production build  # Skip testing appimage, is this dangerous? It's slow...
+        run: |
+          npm run tauri build -- --ci --bundles deb
+      - name: Install production build
+        run: |
+          ls ./src-tauri/target/release/bundle/deb && sudo apt install -y ./src-tauri/target/release/bundle/deb/*.deb
       - name: Setup xvfb for screen 0
-        run: Xvfb :1 -screen 0 1600x1200x24 &
-
-      - name: Test beeai compiler
-        env:
-          DISPLAY: :1
         run: |
-          PATH=./src-tauri/target/release/:$PATH
-
-          for i in ./demos/beeai/*.py
-          do pdl compile beeai $i -g -o /tmp/z.json && jq .description /tmp/z.json
-          done
+          Xvfb :1 -screen 0 1600x1200x24 &
 
-      - name: Test pdl run against production build
+      - name: Test 'pdl run' against production build
         env:
           DISPLAY: :1
         run: |
-          PATH=./src-tauri/target/release/:$PATH
-          
           # 1a. `run` subcommand errors due to missing required positional parameter
           pdl run && (echo "This should have failed" && exit 1) || (echo "Great, expected failure received" && exit 0)
 
@@ -69,9 +62,9 @@ jobs:
           # demo5,demo6 each depend on an external file, and the interpreter does not currently capture this in the trace
           # demo8 currently requires building a model which the interpreter does not directly support
           # demo9 takes forever, so... for now skip it
-          for i in ./src/demos/*.json
-          do if [[ $(basename $i) != "demo4.json" ]] && [[ $(basename $i) != "demo5.json" ]] && [[ $(basename $i) != "demo6.json" ]] && [[ $(basename $i) != "demo8.json" ]] && [[  $(basename $i) != "demo9.json" ]]; then pdl run $i; fi
-          done
+          #for i in ./src/demos/*.json
+          #do if [[ $(basename $i) != "demo4.json" ]] && [[ $(basename $i) != "demo5.json" ]] && [[ $(basename $i) != "demo6.json" ]] && [[ $(basename $i) != "demo8.json" ]] && [[  $(basename $i) != "demo9.json" ]]; then pdl run $i; fi
+          #done
 
       - name: Tear down xvfb
         run: killall Xvfb || true

.pre-commit-config.yaml

@@ -16,18 +16,18 @@ repos:
       - id: debug-statements
   # Clean up imports in Python using isort
   - repo: https://github.com/pycqa/isort
-    rev: 5.13.2
+    rev: 6.0.1
     hooks:
       - id: isort
         args: [--filter-files, --profile, black]
   # Format the python code with black
   - repo: https://github.com/psf/black
-    rev: 24.8.0
+    rev: 25.1.0
     hooks:
       - id: black
   # Lint the python code with flake
   - repo: https://github.com/PyCQA/flake8
-    rev: 7.1.1
+    rev: 7.2.0
     hooks:
       - id: flake8
   # Type check the Python code with pylint
@@ -47,15 +47,16 @@ repos:
           ]
   # run the bandit security linter
   - repo: https://github.com/PyCQA/bandit
-    rev: 1.7.10
+    rev: 1.8.3
     hooks:
       - id: bandit
         args: [-c, bandit.yaml]
   # Type check the Python code with MyPy
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: 'v1.11.2'
+    rev: 'v1.15.0'
     hooks:
       - id: mypy
+        args: [--explicit-package-bases]
         verbose: true
         additional_dependencies: ['types-PyYAML']
   # type check the Python code using pyright

contrib/prompt_library/CoT.pdl

@@ -0,0 +1,54 @@
+description: CoT pattern introduced by Wei et al. (2022)
+defs:
+  # Chain of Thought
+  cot_block:
+    function:
+      question: str
+      reasoning: str
+      answer: str
+    return: |-
+      Question: ${ question }
+      Answer: Let's think step by step. ${ reasoning }
+      The answer is ${ answer }
+
+  fewshot_cot:
+    function:
+      examples:
+        { list: { obj: { question: str, reasoning: str, answer: str } } }
+    return:
+      text:
+        - for:
+            example: ${ examples }
+          repeat:
+            call: ${ cot_block }
+            args:
+              question: ${ example.question }
+              reasoning: ${ example.reasoning }
+              answer: ${ example.answer }
+          join:
+            with: "\n\n"
+
+  chain_of_thought:
+    function:
+      question: str
+      model: str
+      examples:
+        { list: { obj: { question: str, reasoning: str, answer: str } } }
+    return:
+      lastOf:
+        - call: ${ fewshot_cot }
+          args:
+            examples: ${ examples }
+        - "Question: ${ question }\n"
+        - "Answer: Let's think step by step. "
+        - model: ${ model }
+          def: answer
+          parameters:
+            max_tokens: 1024
+            temperature: 0
+            stop:
+              - "<|endoftext|>"
+              - "Question:"
+            include_stop_sequence: false
+        - data:
+            answer: ${ answer|trim }

contrib/prompt_library/ReAct.pdl

@@ -0,0 +1,121 @@
+description: ReAct pattern from Yao et al., [ICLR 2023](https://openreview.net/forum?id=WE_vluYUL-X)
+# See alternative implementation here: https://smith.langchain.com/hub/hwchase17/react-chat
+defs:
+  react_block:
+    function:
+      trajectory: { list: obj }
+    return:
+      text:
+        - for:
+            trajectory: ${ trajectory }
+          repeat:
+            text:
+              - defs:
+                  type:
+                    text: ${ trajectory.keys()|first }
+              - match: ${ type }
+                with:
+                  - case: question
+                    then: |
+                      Question: ${ trajectory[type]|trim }
+                  - case: task
+                    then: |
+                      Task: ${ trajectory[type]|trim }
+                  - case: thought
+                    then: |
+                      Tho: ${ trajectory[type]|trim }
+                  - case: action
+                    then: |
+                      Act: ${ trajectory[type]|trim }
+                  - case: observation
+                    then: |
+                      Obs: ${ trajectory[type]|trim }
+                  - if: ${ type not in ['question', 'task', 'thought', 'action', 'observation'] }
+                    then: "${ type }: ${ trajectory[type]|trim }"
+        - "\n"
+
+  react:
+    function:
+      task: str
+      model: str
+      tool_schema: { list: obj }
+      tools: obj
+      trajectories: { list: list }
+    return:
+      lastOf:
+        - role: system
+          text:
+            - "Today's Date: "
+            - lang: python
+              code: |
+                from datetime import datetime
+                result = datetime.today().strftime('%B %d, %Y.\n')
+            - |
+              You are a helpful assistant with access to the following function calls. Your task is to produce a sequence of function calls necessary to generate response to the user utterance. Use the following function calls as required.
+
+              Respond in the format {"name": function name, "arguments": dictionary of argument name and its value}. Do not use variables.
+
+              ${ tool_schema }
+          contribute: [context]
+        - "\n"
+        - for:
+            traj: ${ trajectories }
+          repeat:
+            text:
+              call: ${ react_block }
+              args:
+                trajectory: ${ traj }
+        - ${ task }
+        - def: prev_action
+          contribute: []
+          data: none
+        - def: exit
+          contribute: []
+          data: False
+        - def: tool_names
+          contribute: []
+          text: ${ tool_schema|map(attribute='name')|list }
+        - repeat:
+            text:
+              - "\nTho: "
+              - def: thought
+                model: "${ model }"
+                contribute: []
+                parameters:
+                  stop:
+                    - "Act:"
+                  max_tokens: 256
+                  include_stop_sequence: false
+              - "${ thought|trim }"
+              - "\nAct: "
+              - def: action
+                model: "${ model }"
+                parser: json
+                parameters:
+                  temperature: 0
+                  stop: ["\n", "Obs:", "<|eom_id|>"]
+                  include_stop_sequence: false
+                spec: { name: str, arguments: obj }
+              - if: ${ action != prev_action }
+                then:
+                  def: observation
+                  if: ${ action.name.lower() != "finish" }
+                  then:
+                    text:
+                      - "\nObs: "
+                      - if: ${ action.name.lower() in tools }
+                        then:
+                          call: ${ tools[action.name.lower()] }
+                          args:
+                            arguments: ${ action.arguments }
+                        else: "Invalid action. Valid actions are ${ tool_names[:-1]|join(', ') }, and ${ tool_names[-1] }."
+                else:
+                  def: exit
+                  contribute: []
+                  data: True
+              - def: prev_action
+                contribute: []
+                data: ${ action }
+          until: ${ action.name.lower() == "finish" or exit }
+        - data:
+            answer: ${ (action.arguments.answer|default("No answer found."))|trim }