actions: instruct=False support

Author: lbeurerkellner

src/lmql/language/compiler.py

@@ -118,7 +118,7 @@ def scope(self, query: LMQLQuery):
 
         # also collect variable reads from where clause
         if query.where is not None:
-            FreeVarCollector(self.free_vars, exclude_criteria=[self.exclude_identifier]).visit(query.where)
+            self.visit_where(query.where)
         if query.from_ast is not None:
             FreeVarCollector(self.free_vars, exclude_criteria=[self.exclude_identifier]).visit(query.from_ast)
         if query.decode is not None:
@@ -131,6 +131,9 @@ def scope(self, query: LMQLQuery):
 
         query.scope = self
 
+    def visit_where(self, node):
+        FreeVarCollector(self.free_vars, exclude_criteria=[self.exclude_identifier]).visit(node)
+
     def visit_Expr(self, expr):
         if type(expr.value) is ast.Constant:
             self.scope_Constant(expr.value)
@@ -140,6 +143,8 @@ def visit_Expr(self, expr):
     def visit_BoolOp(self, node: ast.BoolOp) -> Any:
         if is_query_string_with_constraints(node):
             self.scope_Constant(node.values[0])
+            for constraint in node.values[1:]:
+                self.visit_where(constraint)
         else:
             super().generic_visit(node)
 
@@ -519,7 +524,9 @@ def transform_node(self, expr, snf):
             assert type(expr.func) is ast.Name, "In LMQL constraint expressions, only function calls to direct function references are allowed: {}".format(astunparse.unparse(expr))
             tfunc = ast.unparse(expr.func)
             targs = [self.transform_node(a, snf) for a in expr.args]
-            targs_list = ", ".join(targs)
+            kwargs = [f"('__kw:{e.arg}', {self.transform_node(e.value, snf)})" for e in expr.keywords]
+            targs_list = ", ".join(targs + kwargs)
+
             return f"{OPS_NAMESPACE}.CallOp([{tfunc}, [{targs_list}]], locals(), globals())"
         elif type(expr) is ast.List:
             return self.default_transform_node(expr, snf).strip()

src/lmql/lib/actions.py

@@ -74,86 +74,76 @@ def make_fct(f):
 @lmql.query
 async def fct_call(fcts):
     '''lmql
-    incontext
-        action_fcts = {str(f.__name__): make_fct(f) for f in fcts}
-        "[CALL]"
-        truncated = CALL
-        if not CALL.endswith("|") and not CALL.endswith(DELIMITER_END):
+    action_fcts = {str(f.__name__): make_fct(f) for f in fcts}
+    "[CALL]" where STOPS_AT(CALL, "|") and STOPS_AT(CALL, DELIMITER_END)
+
+    truncated = CALL
+    if not CALL.endswith("|") and not CALL.endswith(DELIMITER_END):
+        return CALL
+    else:    
+        if CALL.endswith(DELIMITER_END):
+            CALL = CALL[:-len(DELIMITER_END)]
+        else:
+            CALL = CALL[:-len("|")]
+        
+        if "(" not in CALL:
             return CALL
-        else:    
-            if CALL.endswith(DELIMITER_END):
-                CALL = CALL[:-len(DELIMITER_END)]
-            else:
-                CALL = CALL[:-len("|")]
-            
-            if "(" not in CALL:
-                return CALL
-            
-            action, args = CALL.split("(", 1)
-            action = action.strip()
-            if action not in action_fcts.keys():
-                print("unknown action", [action], list(action_fcts.keys()))
-                " Unknown action: {action} {DELIMITER_END}"
-                result = ""
+        
+        action, args = CALL.split("(", 1)
+        action = action.strip()
+        if action not in action_fcts.keys():
+            print("unknown action", [action], list(action_fcts.keys()))
+            " Unknown action: {action} {DELIMITER_END}"
+            result = ""
+            return "(error)"
+        else:
+            try:
+                result = await action_fcts[action].call("(" + args.strip())
+                return DELIMITER + str(CALL) + "| " + str(result)
+            except Exception:
+                result = "Error."
                 return "(error)"
-            else:
-                try:
-                    result = await action_fcts[action].call("(" + args.strip())
-                    return DELIMITER + str(CALL) + "| " + str(result)
-                except Exception:
-                    result = "Error."
-                    return "(error)"
-    where
-        STOPS_AT(CALL, "|") and STOPS_AT(CALL, DELIMITER_END)
     '''
 
 
 @lmql.query
 async def inline_segment(fcts):
     '''lmql
-    incontext
-        "[SEGMENT]"
-        if not SEGMENT.endswith(DELIMITER):
-            return SEGMENT
-        else:
-            "[CALL]"
-            result = CALL.split("|", 1)[1]
-            return SEGMENT[:-len(DELIMITER)] + CALL + DELIMITER_END
-    where
-        STOPS_AT(SEGMENT, DELIMITER) and fct_call(CALL, fcts)
+    "[SEGMENT]" where STOPS_AT(SEGMENT, DELIMITER)
+    if not SEGMENT.endswith(DELIMITER):
+        return SEGMENT
+    else:
+        "[CALL]" where fct_call(CALL, fcts) and len(TOKENS(CALL)) > 0
+        result = CALL.split("|", 1)[1]
+        return SEGMENT[:-len(DELIMITER)] + CALL + DELIMITER_END
     '''
 
 @lmql.query
-async def inline_use(fcts):
+async def inline_use(fcts, instruct=True):
     '''lmql
-    incontext
-        action_fcts = {str(f.__name__): make_fct(f) for f in fcts}
-        first_tool_name = list(action_fcts.keys())[0] if len(action_fcts) > 0 else "tool"
+    action_fcts = {str(f.__name__): make_fct(f) for f in fcts}
+    first_tool_name = list(action_fcts.keys())[0] if len(action_fcts) > 0 else "tool"
 
-        # add instruction prompt if no few-shot prompt was already used
-        if not INLINE_USE_PROMPT in context.prompt:
-            """
-            \n\n{:system} Instructions: In your reasoning, you can use the following tools:"""
-            
-            for fct in action_fcts.values():
-                "\n   - {fct.name}: {fct.description} Usage: {DELIMITER}{fct.example} | {fct.example_result}{DELIMITER_END}"
-            '   Example Use: ... this means they had <<calc("5-2") | 3 >> 3 apples left...\n'
-            "   You can also use the tools multiple times in one reasoning step.\n\n"
-            "Reasoning with Tools: {:assistant}"
-        else:
-            "\n\nInline Tool Use:\n\n"
+    # add instruction prompt if no few-shot prompt was already used
+    if instruct and not INLINE_USE_PROMPT in context.prompt:
+        """
+        \n\nInstructions: In your reasoning, you can use the following tools:"""
         
-        # decode segment-by-segment, handling action calls along the way
-        truncated = ""
-        while True: 
-            "[SEGMENT]"
-            if not SEGMENT.endswith(DELIMITER_END):
-                " " # seems to be needed for now
-                return truncated + SEGMENT
-            truncated += SEGMENT
-        return truncated
-    where
-        inline_segment(SEGMENT, fcts)
+        for fct in action_fcts.values():
+            "\n   - {fct.name}: {fct.description} Usage: {DELIMITER}{fct.example} | {fct.example_result}{DELIMITER_END}"
+        '   Example Use: ... this means they had <<calc("5-2") | 3 >> 3 apples left...\n'
+        "   You can also use the tools multiple times in one reasoning step.\n\n"
+        "Reasoning with Tools:\n\n"
+    
+    # decode segment-by-segment, handling action calls along the way
+    truncated = ""
+    while True: 
+        "[SEGMENT]" where inline_segment(SEGMENT, fcts)
+        if not SEGMENT.endswith(DELIMITER_END):
+            " " # seems to be needed for now
+            return truncated + SEGMENT
+        truncated += SEGMENT
+    return truncated
     '''
 inline_use.demonstrations = INLINE_USE_PROMPT
 

src/lmql/ops/inline_call.py

@@ -57,7 +57,13 @@ def forward(self, *args, **kwargs):
     def subinterpreter(self, runtime, prompt, args = None):
         query_kwargs = None
         if args is not None:
-            query_kwargs, _ = self.query_fct.make_kwargs(*args[1:])
+            args = args[1:]
+            def is_kwarg(a):
+                return type(a) is tuple and len(a) == 2 and type(a[0]) is str and a[0].startswith("__kw:")
+            kwargs = {k[0][len("__kw:"):]: k[1] for k in args if is_kwarg(k)}
+            args = [a for a in args if not is_kwarg(a)]
+
+            query_kwargs, _ = self.query_fct.make_kwargs(*args, **kwargs)
             self.query_kwargs = query_kwargs
         else:
             if self.query_kwargs is None:
@@ -89,7 +95,7 @@ def postprocess(self, operands, value):
         return si
 
     def postprocess_order(self, other, operands, other_inputs, **kwargs):
-        return 0 # other constraints cannot be compared
+        return "before" # other constraints cannot be compared
 
     @staticmethod
     def collect(op: Node):